← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/opt_range.h

  • Committer: Monty Taylor
  • Date: 2008-10-16 06:32:30 UTC
  • mto: (511.1.5 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016063230-4brxsra0qsmsg84q
Added -Wunused-macros.

Show diffs side-by-side

added added

removed removed

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