← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/opt_range.h

  • Committer: Monty Taylor
  • Date: 2008-07-05 18:10:38 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: monty@inaugust.com-20080705181038-0ih0nnamu5qrut0y
Fixed prototypes. Cleaned define a little bit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/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
    {
71
70
 
72
71
/*
73
72
  Quick select interface.
74
 
  This class is a parent for all QUICK_*_SELECT classes.
 
73
  This class is a parent for all QUICK_*_SELECT and FT_SELECT classes.
75
74
 
76
75
  The usage scenario is as follows:
77
76
  1. Create quick select
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)))
217
 
  { assert(0); return 1; }
 
215
  virtual int init_ror_merged_scan(bool reuse_handler)
 
216
  { DBUG_ASSERT(0); return 1; }
218
217
 
219
218
  /*
220
219
    Save ROWID of last retrieved row in file->ref. This used in ROR-merging.
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) {};
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;
 
254
#ifndef DBUG_OFF
 
255
  /*
 
256
    Print quick select information to DBUG_FILE. Caller is responsible
 
257
    for locking DBUG_FILE before this call and unlocking it afterwards.
 
258
  */
 
259
  virtual void dbug_dump(int indent, bool verbose)= 0;
 
260
#endif
255
261
};
256
262
 
257
263
 
271
277
  QUICK_RANGE **last;
272
278
} QUICK_RANGE_SEQ_CTX;
273
279
 
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);
 
280
range_seq_t quick_range_seq_init(void *init_param, uint n_ranges, uint flags);
 
281
uint quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
276
282
 
277
283
 
278
284
/*
297
303
  /* Members needed to use the MRR interface */
298
304
  QUICK_RANGE_SEQ_CTX qr_traversal_ctx;
299
305
public:
300
 
  uint32_t mrr_flags; /* Flags to be used with MRR interface */
 
306
  uint mrr_flags; /* Flags to be used with MRR interface */
301
307
protected:
302
 
  uint32_t mrr_buf_size; /* copy from thd->variables.read_rnd_buff_size */  
 
308
  uint mrr_buf_size; /* copy from thd->variables.read_rnd_buff_size */  
303
309
  HANDLER_BUFFER *mrr_buf_desc; /* the handler buffer */
304
310
 
305
311
  /* Info about index we're scanning */
314
320
public:
315
321
  MEM_ROOT alloc;
316
322
 
317
 
  QUICK_RANGE_SELECT(THD *thd, Table *table,uint32_t index_arg,bool no_alloc,
 
323
  QUICK_RANGE_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc,
318
324
                     MEM_ROOT *parent_alloc, bool *create_err);
319
325
  ~QUICK_RANGE_SELECT();
320
326
 
322
328
  int reset(void);
323
329
  int get_next();
324
330
  void range_end();
325
 
  int get_next_prefix(uint32_t prefix_length, key_part_map keypart_map,
326
 
                      unsigned char *cur_prefix);
 
331
  int get_next_prefix(uint prefix_length, key_part_map keypart_map,
 
332
                      uchar *cur_prefix);
327
333
  bool reverse_sorted() { return 0; }
328
334
  bool unique_key_range();
329
335
  int init_ror_merged_scan(bool reuse_handler);
332
338
  int get_type() { return QS_TYPE_RANGE; }
333
339
  void add_keys_and_lengths(String *key_names, String *used_lengths);
334
340
  void add_info_string(String *str);
 
341
#ifndef DBUG_OFF
 
342
  void dbug_dump(int indent, bool verbose);
 
343
#endif
335
344
private:
336
345
  /* Used only by QUICK_SELECT_DESC */
337
346
  QUICK_RANGE_SELECT(const QUICK_RANGE_SELECT& org) : QUICK_SELECT_I()
338
347
  {
339
 
    memmove(this, &org, sizeof(*this));
 
348
    bcopy(&org, this, sizeof(*this));
340
349
    /* 
341
350
      Use default MRR implementation for reverse scans. No table engine
342
351
      currently can do an MRR scan with output in reverse index order.
347
356
  }
348
357
  friend class TRP_ROR_INTERSECT;
349
358
  friend
350
 
  QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, Table *table,
 
359
  QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
351
360
                                               struct st_table_ref *ref,
352
361
                                               ha_rows records);
353
362
  friend bool get_quick_keys(PARAM *param, QUICK_RANGE_SELECT *quick, 
354
363
                             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,
 
364
                             uchar *min_key, uint min_key_flag,
 
365
                             uchar *max_key, uint max_key_flag);
 
366
  friend QUICK_RANGE_SELECT *get_quick_select(PARAM*,uint idx,
358
367
                                              SEL_ARG *key_tree,
359
 
                                              uint32_t mrr_flags,
360
 
                                              uint32_t mrr_buf_size,
 
368
                                              uint mrr_flags,
 
369
                                              uint mrr_buf_size,
361
370
                                              MEM_ROOT *alloc);
362
371
  friend class QUICK_SELECT_DESC;
363
372
  friend class QUICK_INDEX_MERGE_SELECT;
364
373
  friend class QUICK_ROR_INTERSECT_SELECT;
365
374
  friend class QUICK_GROUP_MIN_MAX_SELECT;
366
 
  friend uint32_t quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
 
375
  friend uint quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
367
376
  friend range_seq_t quick_range_seq_init(void *init_param,
368
 
                                          uint32_t n_ranges, uint32_t flags);
 
377
                                          uint n_ranges, uint flags);
369
378
  friend void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
370
379
                              bool distinct,const char *message);
371
380
};
433
442
class QUICK_INDEX_MERGE_SELECT : public QUICK_SELECT_I
434
443
{
435
444
public:
436
 
  QUICK_INDEX_MERGE_SELECT(THD *thd, Table *table);
 
445
  QUICK_INDEX_MERGE_SELECT(THD *thd, TABLE *table);
437
446
  ~QUICK_INDEX_MERGE_SELECT();
438
447
 
439
448
  int  init();
445
454
  void add_keys_and_lengths(String *key_names, String *used_lengths);
446
455
  void add_info_string(String *str);
447
456
  bool is_keys_used(const MY_BITMAP *fields);
 
457
#ifndef DBUG_OFF
 
458
  void dbug_dump(int indent, bool verbose);
 
459
#endif
448
460
 
449
461
  bool push_quick_back(QUICK_RANGE_SELECT *quick_sel_range);
450
462
 
487
499
class QUICK_ROR_INTERSECT_SELECT : public QUICK_SELECT_I
488
500
{
489
501
public:
490
 
  QUICK_ROR_INTERSECT_SELECT(THD *thd, Table *table,
 
502
  QUICK_ROR_INTERSECT_SELECT(THD *thd, TABLE *table,
491
503
                             bool retrieve_full_rows,
492
504
                             MEM_ROOT *parent_alloc);
493
505
  ~QUICK_ROR_INTERSECT_SELECT();
501
513
  void add_keys_and_lengths(String *key_names, String *used_lengths);
502
514
  void add_info_string(String *str);
503
515
  bool is_keys_used(const MY_BITMAP *fields);
 
516
#ifndef DBUG_OFF
 
517
  void dbug_dump(int indent, bool verbose);
 
518
#endif
504
519
  int init_ror_merged_scan(bool reuse_handler);
505
520
  bool push_quick_back(QUICK_RANGE_SELECT *quick_sel_range);
506
521
 
540
555
class QUICK_ROR_UNION_SELECT : public QUICK_SELECT_I
541
556
{
542
557
public:
543
 
  QUICK_ROR_UNION_SELECT(THD *thd, Table *table);
 
558
  QUICK_ROR_UNION_SELECT(THD *thd, TABLE *table);
544
559
  ~QUICK_ROR_UNION_SELECT();
545
560
 
546
561
  int  init();
552
567
  void add_keys_and_lengths(String *key_names, String *used_lengths);
553
568
  void add_info_string(String *str);
554
569
  bool is_keys_used(const MY_BITMAP *fields);
 
570
#ifndef DBUG_OFF
 
571
  void dbug_dump(int indent, bool verbose);
 
572
#endif
555
573
 
556
574
  bool push_quick_back(QUICK_SELECT_I *quick_sel_range);
557
575
 
561
579
  MEM_ROOT alloc; /* Memory pool for this and merged quick selects data. */
562
580
 
563
581
  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() */
 
582
  uchar *cur_rowid;      /* buffer used in get_next() */
 
583
  uchar *prev_rowid;     /* rowid of last row returned by get_next() */
566
584
  bool have_prev_rowid; /* true if prev_rowid has valid data */
567
 
  uint32_t rowid_length;    /* table rowid length */
 
585
  uint rowid_length;    /* table rowid length */
568
586
private:
569
 
  static int queue_cmp(void *arg, unsigned char *val1, unsigned char *val2);
 
587
  static int queue_cmp(void *arg, uchar *val1, uchar *val2);
570
588
  bool scans_inited; 
571
589
};
572
590
 
610
628
  handler *file;         /* The handler used to get data. */
611
629
  JOIN *join;            /* Descriptor of the current query */
612
630
  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. */
 
631
  uchar *record;          /* Buffer where the next record is returned. */
 
632
  uchar *tmp_record;      /* Temporary storage for next_min(), next_max(). */
 
633
  uchar *group_prefix;    /* Key prefix consisting of the GROUP fields. */
 
634
  uint group_prefix_len; /* Length of the group prefix. */
 
635
  uint group_key_parts;  /* A number of keyparts in the group prefix */
 
636
  uchar *last_prefix;     /* Prefix of the last group for detecting EOF. */
619
637
  bool have_min;         /* Specify whether we are computing */
620
638
  bool have_max;         /*   a MIN, a MAX, or both.         */
621
639
  bool seen_first_key;   /* Denotes whether the first key was retrieved.*/
622
640
  KEY_PART_INFO *min_max_arg_part; /* The keypart of the only argument field */
623
641
                                   /* 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;
 
642
  uint min_max_arg_len;  /* The length of the MIN/MAX argument field */
 
643
  uchar *key_infix;       /* Infix of constants from equality predicates. */
 
644
  uint key_infix_len;
627
645
  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.      */
 
646
  uint real_prefix_len; /* Length of key prefix extended with key_infix. */
 
647
  uint real_key_parts;  /* A number of keyparts in the above value.      */
630
648
  List<Item_sum> *min_functions;
631
649
  List<Item_sum> *max_functions;
632
650
  List_iterator<Item_sum> *min_functions_it;
647
665
  void update_min_result();
648
666
  void update_max_result();
649
667
public:
650
 
  QUICK_GROUP_MIN_MAX_SELECT(Table *table, JOIN *join, bool have_min,
 
668
  QUICK_GROUP_MIN_MAX_SELECT(TABLE *table, JOIN *join, bool have_min,
651
669
                             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
 
670
                             uint group_prefix_len, uint group_key_parts,
 
671
                             uint used_key_parts, KEY *index_info, uint
654
672
                             use_index, double read_cost, ha_rows records, uint
655
 
                             key_infix_len, unsigned char *key_infix, MEM_ROOT
 
673
                             key_infix_len, uchar *key_infix, MEM_ROOT
656
674
                             *parent_alloc);
657
675
  ~QUICK_GROUP_MIN_MAX_SELECT();
658
676
  bool add_range(SEL_ARG *sel_range);
666
684
  bool unique_key_range() { return false; }
667
685
  int get_type() { return QS_TYPE_GROUP_MIN_MAX; }
668
686
  void add_keys_and_lengths(String *key_names, String *used_lengths);
 
687
#ifndef DBUG_OFF
 
688
  void dbug_dump(int indent, bool verbose);
 
689
#endif
669
690
};
670
691
 
671
692
 
672
693
class QUICK_SELECT_DESC: public QUICK_RANGE_SELECT
673
694
{
674
695
public:
675
 
  QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint32_t used_key_parts, 
 
696
  QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint used_key_parts, 
676
697
                    bool *create_err);
677
698
  int get_next();
678
699
  bool reverse_sorted() { return 1; }
680
701
private:
681
702
  bool range_reads_after_key(QUICK_RANGE *range);
682
703
#ifdef NOT_USED
683
 
  bool test_if_null_range(QUICK_RANGE *range, uint32_t used_key_parts);
 
704
  bool test_if_null_range(QUICK_RANGE *range, uint used_key_parts);
684
705
#endif
685
706
  int reset(void) { rev_it.rewind(); return QUICK_RANGE_SELECT::reset(); }
686
707
  List<QUICK_RANGE> rev_ranges;
692
713
 public:
693
714
  QUICK_SELECT_I *quick;        // If quick-select used
694
715
  COND          *cond;          // where condition
695
 
  Table *head;
 
716
  TABLE *head;
696
717
  IO_CACHE file;                // Positions to used records
697
718
  ha_rows records;              // Records in use if read from file
698
719
  double read_time;             // Time to read rows
708
729
  {
709
730
    key_map tmp;
710
731
    tmp.set_all();
711
 
    return test_quick_select(thd, tmp, 0, limit, force_quick_range, false) < 0;
 
732
    return test_quick_select(thd, tmp, 0, limit, force_quick_range, FALSE) < 0;
712
733
  }
713
734
  inline bool skip_record() { return cond ? cond->val_int() == 0 : 0; }
714
735
  int test_quick_select(THD *thd, key_map keys, table_map prev_tables,
716
737
                        bool ordered_output);
717
738
};
718
739
 
719
 
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, Table *table,
 
740
QUICK_RANGE_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
720
741
                                             struct st_table_ref *ref,
721
742
                                             ha_rows records);
722
 
uint32_t get_index_for_order(Table *table, order_st *order, ha_rows limit);
 
743
uint get_index_for_order(TABLE *table, ORDER *order, ha_rows limit);
723
744
 
724
745
#endif