← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/opt_range.h

  • Committer: Monty Taylor
  • Date: 2008-07-22 05:48:51 UTC
  • mto: (202.1.3 toru)
  • mto: This revision was merged to the branch mainline in revision 204.
  • Revision ID: monty@inaugust.com-20080722054851-airxt73370725p7x
Re-enabled optimizations for the normal build, and added back the --with-debug option to turn them off. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/opt_range.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
1
/* Copyright (C) 2000-2006 MySQL 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; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
15
 
20
16
 
21
17
/* classes to use when handling where clause */
22
18
 
23
 
#ifndef DRIZZLED_OPT_RANGE_H
24
 
#define DRIZZLED_OPT_RANGE_H
 
19
#ifndef _opt_range_h
 
20
#define _opt_range_h
25
21
 
 
22
#ifdef USE_PRAGMA_INTERFACE
 
23
#pragma interface                       /* gcc class implementation */
 
24
#endif
26
25
 
27
26
typedef struct st_key_part {
28
 
  uint16_t           key,part;
 
27
  uint16           key,part;
29
28
  /* See KEY_PART_INFO for meaning of the next two: */
30
 
  uint16_t           store_length, length;
31
 
  uint8_t            null_bit;
 
29
  uint16           store_length, length;
 
30
  uint8            null_bit;
32
31
  /*
33
32
    Keypart flags (0 when this structure is used by partition pruning code
34
33
    for fake partitioning index description)
35
34
  */
36
 
  uint8_t flag;
 
35
  uint8 flag;
37
36
  Field            *field;
38
37
  Field::imagetype image_type;
39
38
} KEY_PART;
41
40
 
42
41
class QUICK_RANGE :public Sql_alloc {
43
42
 public:
44
 
  unsigned char *min_key,*max_key;
45
 
  uint16_t min_length,max_length,flag;
 
43
  uchar *min_key,*max_key;
 
44
  uint16 min_length,max_length,flag;
46
45
  key_part_map min_keypart_map, // bitmap of used keyparts in min_key
47
46
               max_keypart_map; // bitmap of used keyparts in max_key
48
47
#ifdef HAVE_purify
49
 
  uint16_t dummy;                                       /* Avoid warnings on 'flag' */
 
48
  uint16 dummy;                                 /* Avoid warnings on 'flag' */
50
49
#endif
51
50
  QUICK_RANGE();                                /* Full range */
52
 
  QUICK_RANGE(const unsigned char *min_key_arg, uint32_t min_length_arg,
 
51
  QUICK_RANGE(const uchar *min_key_arg, uint min_length_arg,
53
52
              key_part_map min_keypart_map_arg,
54
 
              const unsigned char *max_key_arg, uint32_t max_length_arg,
 
53
              const uchar *max_key_arg, uint max_length_arg,
55
54
              key_part_map max_keypart_map_arg,
56
 
              uint32_t flag_arg)
57
 
    : min_key((unsigned char*) sql_memdup(min_key_arg,min_length_arg+1)),
58
 
      max_key((unsigned char*) sql_memdup(max_key_arg,max_length_arg+1)),
59
 
      min_length((uint16_t) min_length_arg),
60
 
      max_length((uint16_t) max_length_arg),
61
 
      flag((uint16_t) flag_arg),
 
55
              uint flag_arg)
 
56
    : min_key((uchar*) sql_memdup(min_key_arg,min_length_arg+1)),
 
57
      max_key((uchar*) sql_memdup(max_key_arg,max_length_arg+1)),
 
58
      min_length((uint16) min_length_arg),
 
59
      max_length((uint16) max_length_arg),
 
60
      flag((uint16) flag_arg),
62
61
      min_keypart_map(min_keypart_map_arg),
63
62
      max_keypart_map(max_keypart_map_arg)
64
63
    {
118
117
  bool sorted;
119
118
  ha_rows records;  /* estimate of # of records to be retrieved */
120
119
  double  read_time; /* time to perform this retrieval          */
121
 
  Table   *head;
 
120
  TABLE   *head;
122
121
  /*
123
122
    Index this quick select uses, or MAX_KEY for quick selects
124
123
    that use several indexes
125
124
  */
126
 
  uint32_t index;
 
125
  uint index;
127
126
 
128
127
  /*
129
128
    Total length of first used_key_parts parts of the key.
130
129
    Applicable if index!= MAX_KEY.
131
130
  */
132
 
  uint32_t max_used_key_length;
 
131
  uint max_used_key_length;
133
132
 
134
133
  /*
135
134
    Max. number of (first) key parts this quick select uses for retrieval.
138
137
 
139
138
    For QUICK_GROUP_MIN_MAX_SELECT it includes MIN/MAX argument keyparts.
140
139
  */
141
 
  uint32_t used_key_parts;
 
140
  uint used_key_parts;
142
141
 
143
142
  QUICK_SELECT_I();
144
143
  virtual ~QUICK_SELECT_I(){};
213
212
      0     Ok
214
213
      other Error
215
214
  */
216
 
  virtual int init_ror_merged_scan(bool reuse_handler __attribute__((unused)))
 
215
  virtual int init_ror_merged_scan(bool reuse_handler __attribute__((__unused__)))
217
216
  { assert(0); return 1; }
218
217
 
219
218
  /*
235
234
    This function is implemented only by quick selects that merge other quick
236
235
    selects output and/or can produce output suitable for merging.
237
236
  */
238
 
  virtual void add_info_string(String *str __attribute__((unused))) {};
 
237
  virtual void add_info_string(String *str __attribute__((__unused__))) {};
239
238
  /*
240
239
    Return 1 if any index used by this quick select
241
240
    uses field which is marked in passed bitmap.
246
245
    rowid of last row retrieved by this quick select. This is used only when
247
246
    doing ROR-index_merge selects
248
247
  */
249
 
  unsigned char    *last_rowid;
 
248
  uchar    *last_rowid;
250
249
 
251
250
  /*
252
251
    Table record buffer used by this quick select.
253
252
  */
254
 
  unsigned char    *record;
 
253
  uchar    *record;
255
254
};
256
255
 
257
256
 
271
270
  QUICK_RANGE **last;
272
271
} QUICK_RANGE_SEQ_CTX;
273
272
 
274
 
range_seq_t quick_range_seq_init(void *init_param, uint32_t n_ranges, uint32_t flags);
275
 
uint32_t quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
 
273
range_seq_t quick_range_seq_init(void *init_param, uint n_ranges, uint flags);
 
274
uint quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
276
275
 
277
276
 
278
277
/*
297
296
  /* Members needed to use the MRR interface */
298
297
  QUICK_RANGE_SEQ_CTX qr_traversal_ctx;
299
298
public:
300
 
  uint32_t mrr_flags; /* Flags to be used with MRR interface */
 
299
  uint mrr_flags; /* Flags to be used with MRR interface */
301
300
protected:
302
 
  uint32_t mrr_buf_size; /* copy from thd->variables.read_rnd_buff_size */  
 
301
  uint mrr_buf_size; /* copy from thd->variables.read_rnd_buff_size */  
303
302
  HANDLER_BUFFER *mrr_buf_desc; /* the handler buffer */
304
303
 
305
304
  /* Info about index we're scanning */
314
313
public:
315
314
  MEM_ROOT alloc;
316
315
 
317
 
  QUICK_RANGE_SELECT(THD *thd, Table *table,uint32_t index_arg,bool no_alloc,
 
316
  QUICK_RANGE_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc,
318
317
                     MEM_ROOT *parent_alloc, bool *create_err);
319
318
  ~QUICK_RANGE_SELECT();
320
319
 
322
321
  int reset(void);
323
322
  int get_next();
324
323
  void range_end();
325
 
  int get_next_prefix(uint32_t prefix_length, key_part_map keypart_map,
326
 
                      unsigned char *cur_prefix);
 
324
  int get_next_prefix(uint prefix_length, key_part_map keypart_map,
 
325
                      uchar *cur_prefix);
327
326
  bool reverse_sorted() { return 0; }
328
327
  bool unique_key_range();
329
328
  int init_ror_merged_scan(bool reuse_handler);
336
335
  /* Used only by QUICK_SELECT_DESC */
337
336
  QUICK_RANGE_SELECT(const QUICK_RANGE_SELECT& org) : QUICK_SELECT_I()
338
337
  {
339
 
    memmove(this, &org, sizeof(*this));
 
338
    bcopy(&org, this, sizeof(*this));
340
339
    /* 
341
340
      Use default MRR implementation for reverse scans. No table engine
342
341
      currently can do an MRR scan with output in reverse index order.
347
346
  }
348
347
  friend class TRP_ROR_INTERSECT;
349
348
  friend
350
 
  QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, Table *table,
 
349
  QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
351
350
                                               struct st_table_ref *ref,
352
351
                                               ha_rows records);
353
352
  friend bool get_quick_keys(PARAM *param, QUICK_RANGE_SELECT *quick, 
354
353
                             KEY_PART *key, SEL_ARG *key_tree, 
355
 
                             unsigned char *min_key, uint32_t min_key_flag,
356
 
                             unsigned char *max_key, uint32_t max_key_flag);
357
 
  friend QUICK_RANGE_SELECT *get_quick_select(PARAM*,uint32_t idx,
 
354
                             uchar *min_key, uint min_key_flag,
 
355
                             uchar *max_key, uint max_key_flag);
 
356
  friend QUICK_RANGE_SELECT *get_quick_select(PARAM*,uint idx,
358
357
                                              SEL_ARG *key_tree,
359
 
                                              uint32_t mrr_flags,
360
 
                                              uint32_t mrr_buf_size,
 
358
                                              uint mrr_flags,
 
359
                                              uint mrr_buf_size,
361
360
                                              MEM_ROOT *alloc);
362
361
  friend class QUICK_SELECT_DESC;
363
362
  friend class QUICK_INDEX_MERGE_SELECT;
364
363
  friend class QUICK_ROR_INTERSECT_SELECT;
365
364
  friend class QUICK_GROUP_MIN_MAX_SELECT;
366
 
  friend uint32_t quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
 
365
  friend uint quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
367
366
  friend range_seq_t quick_range_seq_init(void *init_param,
368
 
                                          uint32_t n_ranges, uint32_t flags);
 
367
                                          uint n_ranges, uint flags);
369
368
  friend void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
370
369
                              bool distinct,const char *message);
371
370
};
433
432
class QUICK_INDEX_MERGE_SELECT : public QUICK_SELECT_I
434
433
{
435
434
public:
436
 
  QUICK_INDEX_MERGE_SELECT(THD *thd, Table *table);
 
435
  QUICK_INDEX_MERGE_SELECT(THD *thd, TABLE *table);
437
436
  ~QUICK_INDEX_MERGE_SELECT();
438
437
 
439
438
  int  init();
487
486
class QUICK_ROR_INTERSECT_SELECT : public QUICK_SELECT_I
488
487
{
489
488
public:
490
 
  QUICK_ROR_INTERSECT_SELECT(THD *thd, Table *table,
 
489
  QUICK_ROR_INTERSECT_SELECT(THD *thd, TABLE *table,
491
490
                             bool retrieve_full_rows,
492
491
                             MEM_ROOT *parent_alloc);
493
492
  ~QUICK_ROR_INTERSECT_SELECT();
540
539
class QUICK_ROR_UNION_SELECT : public QUICK_SELECT_I
541
540
{
542
541
public:
543
 
  QUICK_ROR_UNION_SELECT(THD *thd, Table *table);
 
542
  QUICK_ROR_UNION_SELECT(THD *thd, TABLE *table);
544
543
  ~QUICK_ROR_UNION_SELECT();
545
544
 
546
545
  int  init();
561
560
  MEM_ROOT alloc; /* Memory pool for this and merged quick selects data. */
562
561
 
563
562
  THD *thd;             /* current thread */
564
 
  unsigned char *cur_rowid;      /* buffer used in get_next() */
565
 
  unsigned char *prev_rowid;     /* rowid of last row returned by get_next() */
 
563
  uchar *cur_rowid;      /* buffer used in get_next() */
 
564
  uchar *prev_rowid;     /* rowid of last row returned by get_next() */
566
565
  bool have_prev_rowid; /* true if prev_rowid has valid data */
567
 
  uint32_t rowid_length;    /* table rowid length */
 
566
  uint rowid_length;    /* table rowid length */
568
567
private:
569
 
  static int queue_cmp(void *arg, unsigned char *val1, unsigned char *val2);
 
568
  static int queue_cmp(void *arg, uchar *val1, uchar *val2);
570
569
  bool scans_inited; 
571
570
};
572
571
 
610
609
  handler *file;         /* The handler used to get data. */
611
610
  JOIN *join;            /* Descriptor of the current query */
612
611
  KEY  *index_info;      /* The index chosen for data access */
613
 
  unsigned char *record;          /* Buffer where the next record is returned. */
614
 
  unsigned char *tmp_record;      /* Temporary storage for next_min(), next_max(). */
615
 
  unsigned char *group_prefix;    /* Key prefix consisting of the GROUP fields. */
616
 
  uint32_t group_prefix_len; /* Length of the group prefix. */
617
 
  uint32_t group_key_parts;  /* A number of keyparts in the group prefix */
618
 
  unsigned char *last_prefix;     /* Prefix of the last group for detecting EOF. */
 
612
  uchar *record;          /* Buffer where the next record is returned. */
 
613
  uchar *tmp_record;      /* Temporary storage for next_min(), next_max(). */
 
614
  uchar *group_prefix;    /* Key prefix consisting of the GROUP fields. */
 
615
  uint group_prefix_len; /* Length of the group prefix. */
 
616
  uint group_key_parts;  /* A number of keyparts in the group prefix */
 
617
  uchar *last_prefix;     /* Prefix of the last group for detecting EOF. */
619
618
  bool have_min;         /* Specify whether we are computing */
620
619
  bool have_max;         /*   a MIN, a MAX, or both.         */
621
620
  bool seen_first_key;   /* Denotes whether the first key was retrieved.*/
622
621
  KEY_PART_INFO *min_max_arg_part; /* The keypart of the only argument field */
623
622
                                   /* of all MIN/MAX functions.              */
624
 
  uint32_t min_max_arg_len;  /* The length of the MIN/MAX argument field */
625
 
  unsigned char *key_infix;       /* Infix of constants from equality predicates. */
626
 
  uint32_t key_infix_len;
 
623
  uint min_max_arg_len;  /* The length of the MIN/MAX argument field */
 
624
  uchar *key_infix;       /* Infix of constants from equality predicates. */
 
625
  uint key_infix_len;
627
626
  DYNAMIC_ARRAY min_max_ranges; /* Array of range ptrs for the MIN/MAX field. */
628
 
  uint32_t real_prefix_len; /* Length of key prefix extended with key_infix. */
629
 
  uint32_t real_key_parts;  /* A number of keyparts in the above value.      */
 
627
  uint real_prefix_len; /* Length of key prefix extended with key_infix. */
 
628
  uint real_key_parts;  /* A number of keyparts in the above value.      */
630
629
  List<Item_sum> *min_functions;
631
630
  List<Item_sum> *max_functions;
632
631
  List_iterator<Item_sum> *min_functions_it;
647
646
  void update_min_result();
648
647
  void update_max_result();
649
648
public:
650
 
  QUICK_GROUP_MIN_MAX_SELECT(Table *table, JOIN *join, bool have_min,
 
649
  QUICK_GROUP_MIN_MAX_SELECT(TABLE *table, JOIN *join, bool have_min,
651
650
                             bool have_max, KEY_PART_INFO *min_max_arg_part,
652
 
                             uint32_t group_prefix_len, uint32_t group_key_parts,
653
 
                             uint32_t used_key_parts, KEY *index_info, uint
 
651
                             uint group_prefix_len, uint group_key_parts,
 
652
                             uint used_key_parts, KEY *index_info, uint
654
653
                             use_index, double read_cost, ha_rows records, uint
655
 
                             key_infix_len, unsigned char *key_infix, MEM_ROOT
 
654
                             key_infix_len, uchar *key_infix, MEM_ROOT
656
655
                             *parent_alloc);
657
656
  ~QUICK_GROUP_MIN_MAX_SELECT();
658
657
  bool add_range(SEL_ARG *sel_range);
672
671
class QUICK_SELECT_DESC: public QUICK_RANGE_SELECT
673
672
{
674
673
public:
675
 
  QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint32_t used_key_parts, 
 
674
  QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint used_key_parts, 
676
675
                    bool *create_err);
677
676
  int get_next();
678
677
  bool reverse_sorted() { return 1; }
680
679
private:
681
680
  bool range_reads_after_key(QUICK_RANGE *range);
682
681
#ifdef NOT_USED
683
 
  bool test_if_null_range(QUICK_RANGE *range, uint32_t used_key_parts);
 
682
  bool test_if_null_range(QUICK_RANGE *range, uint used_key_parts);
684
683
#endif
685
684
  int reset(void) { rev_it.rewind(); return QUICK_RANGE_SELECT::reset(); }
686
685
  List<QUICK_RANGE> rev_ranges;
692
691
 public:
693
692
  QUICK_SELECT_I *quick;        // If quick-select used
694
693
  COND          *cond;          // where condition
695
 
  Table *head;
 
694
  TABLE *head;
696
695
  IO_CACHE file;                // Positions to used records
697
696
  ha_rows records;              // Records in use if read from file
698
697
  double read_time;             // Time to read rows
716
715
                        bool ordered_output);
717
716
};
718
717
 
719
 
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, Table *table,
 
718
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
720
719
                                             struct st_table_ref *ref,
721
720
                                             ha_rows records);
722
 
uint32_t get_index_for_order(Table *table, order_st *order, ha_rows limit);
 
721
uint get_index_for_order(TABLE *table, ORDER *order, ha_rows limit);
723
722
 
724
723
#endif