← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/quick_group_min_max_select.cc

  • Committer: Olaf van der Spek
  • Date: 2011-06-22 19:56:58 UTC
  • mto: This revision was merged to the branch mainline in revision 2347.
  • Revision ID: olafvdspek@gmail.com-20110622195658-h9jn0gtyng4f2ne2
Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/quick_group_min_max_select.cc
37
37
using namespace std;
38
38
 
39
39
namespace drizzled {
 
40
namespace optimizer {
40
41
 
41
 
optimizer::QuickGroupMinMaxSelect::
42
 
QuickGroupMinMaxSelect(Table *table,
 
42
QuickGroupMinMaxSelect::QuickGroupMinMaxSelect(Table *table,
43
43
                       Join *join_arg,
44
44
                       bool have_min_arg,
45
45
                       bool have_max_arg,
96
96
}
97
97
 
98
98
 
99
 
int optimizer::QuickGroupMinMaxSelect::init()
 
99
int QuickGroupMinMaxSelect::init()
100
100
{
101
101
  if (group_prefix) /* Already initialized. */
102
102
    return 0;
140
140
  return 0;
141
141
}
142
142
 
143
 
optimizer::QuickGroupMinMaxSelect::~QuickGroupMinMaxSelect()
 
143
QuickGroupMinMaxSelect::~QuickGroupMinMaxSelect()
144
144
{
145
145
  if (cursor->inited != Cursor::NONE)
146
146
  {
160
160
}
161
161
 
162
162
 
163
 
bool optimizer::QuickGroupMinMaxSelect::add_range(optimizer::SEL_ARG *sel_range)
 
163
bool QuickGroupMinMaxSelect::add_range(SEL_ARG *sel_range)
164
164
{
165
 
  optimizer::QuickRange *range= NULL;
 
165
  QuickRange *range= NULL;
166
166
  uint32_t range_flag= sel_range->min_flag | sel_range->max_flag;
167
167
 
168
168
  /* Skip (-inf,+inf) ranges, e.g. (x < 5 or x > 4). */
179
179
                    min_max_arg_len) == 0)
180
180
      range_flag|= EQ_RANGE;  /* equality condition */
181
181
  }
182
 
  range= new optimizer::QuickRange(sel_range->min_value,
 
182
  range= new QuickRange(sel_range->min_value,
183
183
                                   min_max_arg_len,
184
184
                                   make_keypart_map(sel_range->part),
185
185
                                   sel_range->max_value,
193
193
}
194
194
 
195
195
 
196
 
void optimizer::QuickGroupMinMaxSelect::adjust_prefix_ranges()
 
196
void QuickGroupMinMaxSelect::adjust_prefix_ranges()
197
197
{
198
198
  if (quick_prefix_select &&
199
199
      group_prefix_len < quick_prefix_select->max_used_key_length)
200
200
  {
201
201
    DYNAMIC_ARRAY& arr= quick_prefix_select->ranges;
202
202
    for (size_t inx= 0; inx < arr.size(); inx++)
203
 
      reinterpret_cast<optimizer::QuickRange**>(arr.buffer)[inx]->flag &= ~(NEAR_MIN | NEAR_MAX);
 
203
      reinterpret_cast<QuickRange**>(arr.buffer)[inx]->flag &= ~(NEAR_MIN | NEAR_MAX);
204
204
  }
205
205
}
206
206
 
207
207
 
208
 
void optimizer::QuickGroupMinMaxSelect::update_key_stat()
 
208
void QuickGroupMinMaxSelect::update_key_stat()
209
209
{
210
210
  max_used_key_length= real_prefix_len;
211
211
  if (! min_max_ranges.empty())
212
212
  {
213
 
    optimizer::QuickRange *cur_range= NULL;
 
213
    QuickRange *cur_range= NULL;
214
214
    if (have_min)
215
215
    { /* Check if the right-most range has a lower boundary. */
216
216
      cur_range= min_max_ranges.back();
249
249
}
250
250
 
251
251
 
252
 
int optimizer::QuickGroupMinMaxSelect::reset(void)
 
252
int QuickGroupMinMaxSelect::reset(void)
253
253
{
254
254
  int result;
255
255
 
268
268
}
269
269
 
270
270
 
271
 
int optimizer::QuickGroupMinMaxSelect::get_next()
 
271
int QuickGroupMinMaxSelect::get_next()
272
272
{
273
273
  int min_res= 0;
274
274
  int max_res= 0;
348
348
}
349
349
 
350
350
 
351
 
int optimizer::QuickGroupMinMaxSelect::next_min()
 
351
int QuickGroupMinMaxSelect::next_min()
352
352
{
353
353
  int result= 0;
354
354
 
413
413
}
414
414
 
415
415
 
416
 
int optimizer::QuickGroupMinMaxSelect::next_max()
 
416
int QuickGroupMinMaxSelect::next_max()
417
417
{
418
418
  /* Get the last key in the (possibly extended) group. */
419
419
  return min_max_ranges.empty()
422
422
}
423
423
 
424
424
 
425
 
int optimizer::QuickGroupMinMaxSelect::next_prefix()
 
425
int QuickGroupMinMaxSelect::next_prefix()
426
426
{
427
427
  int result= 0;
428
428
 
468
468
}
469
469
 
470
470
 
471
 
int optimizer::QuickGroupMinMaxSelect::next_min_in_range()
 
471
int QuickGroupMinMaxSelect::next_min_in_range()
472
472
{
473
473
  ha_rkey_function find_flag;
474
474
  key_part_map keypart_map;
475
 
  optimizer::QuickRange *cur_range= NULL;
 
475
  QuickRange *cur_range= NULL;
476
476
  bool found_null= false;
477
477
  int result= HA_ERR_KEY_NOT_FOUND;
478
478
  basic_string<unsigned char> max_key;
481
481
 
482
482
  assert(! min_max_ranges.empty());
483
483
 
484
 
  for (vector<optimizer::QuickRange *>::iterator it= min_max_ranges.begin(); it != min_max_ranges.end(); ++it)
 
484
  for (vector<QuickRange *>::iterator it= min_max_ranges.begin(); it != min_max_ranges.end(); ++it)
485
485
  { /* Search from the left-most range to the right. */
486
486
    cur_range= *it;
487
487
 
586
586
}
587
587
 
588
588
 
589
 
int optimizer::QuickGroupMinMaxSelect::next_max_in_range()
 
589
int QuickGroupMinMaxSelect::next_max_in_range()
590
590
{
591
591
  ha_rkey_function find_flag;
592
592
  key_part_map keypart_map;
593
 
  optimizer::QuickRange *cur_range= NULL;
 
593
  QuickRange *cur_range= NULL;
594
594
  int result= 0;
595
595
  basic_string<unsigned char> min_key;
596
596
  min_key.reserve(real_prefix_len + min_max_arg_len);
597
597
 
598
598
  assert(! min_max_ranges.empty());
599
599
 
600
 
  for (vector<optimizer::QuickRange *>::reverse_iterator rit= min_max_ranges.rbegin();
 
600
  for (vector<QuickRange *>::reverse_iterator rit= min_max_ranges.rbegin();
601
601
       rit != min_max_ranges.rend();
602
602
       ++rit)
603
603
  { /* Search from the right-most range to the left. */
676
676
}
677
677
 
678
678
 
679
 
void optimizer::QuickGroupMinMaxSelect::update_min_result()
 
679
void QuickGroupMinMaxSelect::update_min_result()
680
680
{
681
681
  *min_functions_it= min_functions->begin();
682
682
  for (Item_sum *min_func; (min_func= (*min_functions_it)++); )
684
684
}
685
685
 
686
686
 
687
 
void optimizer::QuickGroupMinMaxSelect::update_max_result()
 
687
void QuickGroupMinMaxSelect::update_max_result()
688
688
{
689
689
  *max_functions_it= max_functions->begin();
690
690
  for (Item_sum *max_func; (max_func= (*max_functions_it)++); )
692
692
}
693
693
 
694
694
 
695
 
void optimizer::QuickGroupMinMaxSelect::add_keys_and_lengths(string *key_names,
 
695
void QuickGroupMinMaxSelect::add_keys_and_lengths(string *key_names,
696
696
                                                             string *used_lengths)
697
697
{
698
698
  char buf[64];
701
701
  used_lengths->append(buf, length);
702
702
}
703
703
 
 
704
}
704
705
} /* namespace drizzled */