← Back to branch summary

~ubuntu-branches/ubuntu/saucy/drizzle/saucy-proposed

« back to all changes in this revision

Viewing changes to drizzled/optimizer/quick_range_select.cc

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-03-18 12:12:31 UTC
  • Revision ID: james.westby@ubuntu.com-20100318121231-k6g1xe6cshbwa0f8
Tags: upstream-2010.03.1347
Import upstream version 2010.03.1347

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/quick_range_select.cc
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008-2009 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
 */
 
19
 
 
20
#include "config.h"
 
21
#include "drizzled/session.h"
 
22
#include "drizzled/optimizer/quick_range.h"
 
23
#include "drizzled/optimizer/quick_range_select.h"
 
24
#include "drizzled/sql_bitmap.h"
 
25
#include "drizzled/internal/m_string.h"
 
26
#include <fcntl.h>
 
27
#include "drizzled/memory/multi_malloc.h"
 
28
 
 
29
using namespace std;
 
30
 
 
31
namespace drizzled
 
32
{
 
33
 
 
34
 
 
35
optimizer::QuickRangeSelect::QuickRangeSelect(Session *session,
 
36
                                              Table *table,
 
37
                                              uint32_t key_nr,
 
38
                                              bool no_alloc,
 
39
                                              memory::Root *parent_alloc,
 
40
                                              bool *create_error)
 
41
  :
 
42
    mrr_flags(0),
 
43
    alloc(),
 
44
    cursor(NULL),
 
45
    ranges(),
 
46
    in_ror_merged_scan(false),
 
47
    column_bitmap(),
 
48
    save_read_set(NULL),
 
49
    save_write_set(NULL),
 
50
    free_file(false),
 
51
    cur_range(NULL),
 
52
    last_range(NULL),
 
53
    qr_traversal_ctx(),
 
54
    mrr_buf_size(0),
 
55
    mrr_buf_desc(NULL),
 
56
    key_parts(NULL),
 
57
    dont_free(false)
 
58
{
 
59
  my_bitmap_map *bitmap= NULL;
 
60
 
 
61
  sorted= 0;
 
62
  index= key_nr;
 
63
  head= table;
 
64
  key_part_info= head->key_info[index].key_part;
 
65
  my_init_dynamic_array(&ranges, sizeof(optimizer::QuickRange*), 16, 16);
 
66
 
 
67
  /* 'session' is not accessible in QuickRangeSelect::reset(). */
 
68
  mrr_buf_size= session->variables.read_rnd_buff_size;
 
69
  mrr_buf_desc= NULL;
 
70
 
 
71
  if (! no_alloc && ! parent_alloc)
 
72
  {
 
73
    // Allocates everything through the internal memroot
 
74
    memory::init_sql_alloc(&alloc, session->variables.range_alloc_block_size, 0);
 
75
    session->mem_root= &alloc;
 
76
  }
 
77
  else
 
78
  {
 
79
    memset(&alloc, 0, sizeof(alloc));
 
80
  }
 
81
 
 
82
  cursor= head->cursor;
 
83
  record= head->record[0];
 
84
  save_read_set= head->read_set;
 
85
  save_write_set= head->write_set;
 
86
 
 
87
  /* Allocate a bitmap for used columns. Using memory::sql_alloc instead of malloc
 
88
     simply as a "fix" to the MySQL 6.0 code that also free()s it at the
 
89
     same time we destroy the mem_root.
 
90
   */
 
91
 
 
92
  bitmap= reinterpret_cast<my_bitmap_map*>(memory::sql_alloc(head->s->column_bitmap_size));
 
93
  if (! bitmap)
 
94
  {
 
95
    column_bitmap.setBitmap(NULL);
 
96
    *create_error= 1;
 
97
  }
 
98
  else
 
99
  {
 
100
    column_bitmap.init(bitmap, head->s->fields);
 
101
  }
 
102
}
 
103
 
 
104
 
 
105
int optimizer::QuickRangeSelect::init()
 
106
{
 
107
  if (cursor->inited != Cursor::NONE)
 
108
    cursor->ha_index_or_rnd_end();
 
109
  return (cursor->ha_index_init(index, 1));
 
110
}
 
111
 
 
112
 
 
113
void optimizer::QuickRangeSelect::range_end()
 
114
{
 
115
  if (cursor->inited != Cursor::NONE)
 
116
    cursor->ha_index_or_rnd_end();
 
117
}
 
118
 
 
119
 
 
120
optimizer::QuickRangeSelect::~QuickRangeSelect()
 
121
{
 
122
  if (! dont_free)
 
123
  {
 
124
    /* cursor is NULL for CPK scan on covering ROR-intersection */
 
125
    if (cursor)
 
126
    {
 
127
      range_end();
 
128
      if (head->key_read)
 
129
      {
 
130
        head->key_read= 0;
 
131
        cursor->extra(HA_EXTRA_NO_KEYREAD);
 
132
      }
 
133
      if (free_file)
 
134
      {
 
135
        cursor->ha_external_lock(current_session, F_UNLCK);
 
136
        cursor->close();
 
137
        delete cursor;
 
138
      }
 
139
    }
 
140
    delete_dynamic(&ranges); /* ranges are allocated in alloc */
 
141
    free_root(&alloc,MYF(0));
 
142
  }
 
143
  head->column_bitmaps_set(save_read_set, save_write_set);
 
144
  assert(mrr_buf_desc == NULL);
 
145
  if (mrr_buf_desc)
 
146
  {
 
147
    free(mrr_buf_desc);
 
148
  }
 
149
}
 
150
 
 
151
 
 
152
int optimizer::QuickRangeSelect::init_ror_merged_scan(bool reuse_handler)
 
153
{
 
154
  Cursor *save_file= cursor, *org_file;
 
155
  Session *session;
 
156
 
 
157
  in_ror_merged_scan= 1;
 
158
  if (reuse_handler)
 
159
  {
 
160
    if (init() || reset())
 
161
    {
 
162
      return 0;
 
163
    }
 
164
    head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
165
    goto end;
 
166
  }
 
167
 
 
168
  /* Create a separate Cursor object for this quick select */
 
169
  if (free_file)
 
170
  {
 
171
    /* already have own 'Cursor' object. */
 
172
    return 0;
 
173
  }
 
174
 
 
175
  session= head->in_use;
 
176
  if (! (cursor= head->cursor->clone(session->mem_root)))
 
177
  {
 
178
    /*
 
179
      Manually set the error flag. Note: there seems to be quite a few
 
180
      places where a failure could cause the server to "hang" the client by
 
181
      sending no response to a query. ATM those are not real errors because
 
182
      the storage engine calls in question happen to never fail with the
 
183
      existing storage engines.
 
184
    */
 
185
    my_error(ER_OUT_OF_RESOURCES, MYF(0));
 
186
    /* Caller will free the memory */
 
187
    goto failure;
 
188
  }
 
189
 
 
190
  head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
191
 
 
192
  if (cursor->ha_external_lock(session, F_RDLCK))
 
193
    goto failure;
 
194
 
 
195
  if (init() || reset())
 
196
  {
 
197
    cursor->ha_external_lock(session, F_UNLCK);
 
198
    cursor->close();
 
199
    goto failure;
 
200
  }
 
201
  free_file= true;
 
202
  last_rowid= cursor->ref;
 
203
 
 
204
end:
 
205
  /*
 
206
    We are only going to read key fields and call position() on 'cursor'
 
207
    The following sets head->tmp_set to only use this key and then updates
 
208
    head->read_set and head->write_set to use this bitmap.
 
209
    The now bitmap is stored in 'column_bitmap' which is used in ::get_next()
 
210
  */
 
211
  org_file= head->cursor;
 
212
  head->cursor= cursor;
 
213
  /* We don't have to set 'head->keyread' here as the 'cursor' is unique */
 
214
  if (! head->no_keyread)
 
215
  {
 
216
    head->key_read= 1;
 
217
    head->mark_columns_used_by_index(index);
 
218
  }
 
219
  head->prepare_for_position();
 
220
  head->cursor= org_file;
 
221
  column_bitmap= *head->read_set;
 
222
  head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
223
 
 
224
  return 0;
 
225
 
 
226
failure:
 
227
  head->column_bitmaps_set(save_read_set, save_write_set);
 
228
  delete cursor;
 
229
  cursor= save_file;
 
230
  return 0;
 
231
}
 
232
 
 
233
 
 
234
void optimizer::QuickRangeSelect::save_last_pos()
 
235
{
 
236
  cursor->position(record);
 
237
}
 
238
 
 
239
 
 
240
bool optimizer::QuickRangeSelect::unique_key_range() const
 
241
{
 
242
  if (ranges.elements == 1)
 
243
  {
 
244
    optimizer::QuickRange *tmp= *((optimizer::QuickRange**)ranges.buffer);
 
245
    if ((tmp->flag & (EQ_RANGE | NULL_RANGE)) == EQ_RANGE)
 
246
    {
 
247
      KEY *key=head->key_info+index;
 
248
      return ((key->flags & (HA_NOSAME)) == HA_NOSAME &&
 
249
              key->key_length == tmp->min_length);
 
250
    }
 
251
  }
 
252
  return false;
 
253
}
 
254
 
 
255
 
 
256
int optimizer::QuickRangeSelect::reset()
 
257
{
 
258
  uint32_t buf_size= 0;
 
259
  unsigned char *mrange_buff= NULL;
 
260
  int error= 0;
 
261
  HANDLER_BUFFER empty_buf;
 
262
  last_range= NULL;
 
263
  cur_range= (optimizer::QuickRange**) ranges.buffer;
 
264
 
 
265
  if (cursor->inited == Cursor::NONE && (error= cursor->ha_index_init(index, 1)))
 
266
  {
 
267
    return error;
 
268
  }
 
269
 
 
270
  /* Allocate buffer if we need one but haven't allocated it yet */
 
271
  if (mrr_buf_size && ! mrr_buf_desc)
 
272
  {
 
273
    buf_size= mrr_buf_size;
 
274
    while (buf_size && ! memory::multi_malloc(false,
 
275
                                              &mrr_buf_desc,
 
276
                                              sizeof(*mrr_buf_desc),
 
277
                                              &mrange_buff,
 
278
                                              buf_size,
 
279
                                              NULL))
 
280
    {
 
281
      /* Try to shrink the buffers until both are 0. */
 
282
      buf_size/= 2;
 
283
    }
 
284
    if (! mrr_buf_desc)
 
285
    {
 
286
      return HA_ERR_OUT_OF_MEM;
 
287
    }
 
288
 
 
289
    /* Initialize the Cursor buffer. */
 
290
    mrr_buf_desc->buffer= mrange_buff;
 
291
    mrr_buf_desc->buffer_end= mrange_buff + buf_size;
 
292
    mrr_buf_desc->end_of_used_area= mrange_buff;
 
293
  }
 
294
 
 
295
  if (! mrr_buf_desc)
 
296
  {
 
297
    empty_buf.buffer= NULL;
 
298
    empty_buf.buffer_end= NULL;
 
299
    empty_buf.end_of_used_area= NULL;
 
300
  }
 
301
 
 
302
  if (sorted)
 
303
  {
 
304
     mrr_flags|= HA_MRR_SORTED;
 
305
  }
 
306
  RANGE_SEQ_IF seq_funcs= {
 
307
    optimizer::quick_range_seq_init,
 
308
    optimizer::quick_range_seq_next
 
309
  };
 
310
  error= cursor->multi_range_read_init(&seq_funcs,
 
311
                                       (void*) this,
 
312
                                       ranges.elements,
 
313
                                       mrr_flags,
 
314
                                       mrr_buf_desc ? mrr_buf_desc : &empty_buf);
 
315
  return error;
 
316
}
 
317
 
 
318
 
 
319
int optimizer::QuickRangeSelect::get_next()
 
320
{
 
321
  char *dummy= NULL;
 
322
  if (in_ror_merged_scan)
 
323
  {
 
324
    /*
 
325
      We don't need to signal the bitmap change as the bitmap is always the
 
326
      same for this head->cursor
 
327
    */
 
328
    head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
329
  }
 
330
 
 
331
  int result= cursor->multi_range_read_next(&dummy);
 
332
 
 
333
  if (in_ror_merged_scan)
 
334
  {
 
335
    /* Restore bitmaps set on entry */
 
336
    head->column_bitmaps_set(save_read_set, save_write_set);
 
337
  }
 
338
  return result;
 
339
}
 
340
 
 
341
 
 
342
int optimizer::QuickRangeSelect::get_next_prefix(uint32_t prefix_length,
 
343
                                                 key_part_map keypart_map,
 
344
                                                 unsigned char *cur_prefix)
 
345
{
 
346
  for (;;)
 
347
  {
 
348
    int result;
 
349
    key_range start_key, end_key;
 
350
    if (last_range)
 
351
    {
 
352
      /* Read the next record in the same range with prefix after cur_prefix. */
 
353
      assert(cur_prefix != 0);
 
354
      result= cursor->index_read_map(record,
 
355
                                     cur_prefix,
 
356
                                     keypart_map,
 
357
                                     HA_READ_AFTER_KEY);
 
358
      if (result || (cursor->compare_key(cursor->end_range) <= 0))
 
359
        return result;
 
360
    }
 
361
 
 
362
    uint32_t count= ranges.elements - (cur_range - (optimizer::QuickRange**) ranges.buffer);
 
363
    if (count == 0)
 
364
    {
 
365
      /* Ranges have already been used up before. None is left for read. */
 
366
      last_range= 0;
 
367
      return HA_ERR_END_OF_FILE;
 
368
    }
 
369
    last_range= *(cur_range++);
 
370
 
 
371
    start_key.key= (const unsigned char*) last_range->min_key;
 
372
    start_key.length= min(last_range->min_length, (uint16_t)prefix_length);
 
373
    start_key.keypart_map= last_range->min_keypart_map & keypart_map;
 
374
    start_key.flag= ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
 
375
                                                                (last_range->flag & EQ_RANGE) ?
 
376
                                                                HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
 
377
    end_key.key= (const unsigned char*) last_range->max_key;
 
378
    end_key.length= min(last_range->max_length, (uint16_t)prefix_length);
 
379
    end_key.keypart_map= last_range->max_keypart_map & keypart_map;
 
380
    /*
 
381
      We use READ_AFTER_KEY here because if we are reading on a key
 
382
      prefix we want to find all keys with this prefix
 
383
    */
 
384
    end_key.flag= (last_range->flag & NEAR_MAX ? HA_READ_BEFORE_KEY :
 
385
                                                             HA_READ_AFTER_KEY);
 
386
 
 
387
    result= cursor->read_range_first(last_range->min_keypart_map ? &start_key : 0,
 
388
                                                             last_range->max_keypart_map ? &end_key : 0,
 
389
                                     test(last_range->flag & EQ_RANGE),
 
390
                                                             sorted);
 
391
    if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
 
392
      last_range= 0; // Stop searching
 
393
 
 
394
    if (result != HA_ERR_END_OF_FILE)
 
395
      return result;
 
396
    last_range= 0; // No matching rows; go to next range
 
397
  }
 
398
}
 
399
 
 
400
 
 
401
bool optimizer::QuickRangeSelect::row_in_ranges()
 
402
{
 
403
  optimizer::QuickRange *res= NULL;
 
404
  uint32_t min= 0;
 
405
  uint32_t max= ranges.elements - 1;
 
406
  uint32_t mid= (max + min) / 2;
 
407
 
 
408
  while (min != max)
 
409
  {
 
410
    if (cmp_next(*(optimizer::QuickRange**)dynamic_array_ptr(&ranges, mid)))
 
411
    {
 
412
      /* current row value > mid->max */
 
413
      min= mid + 1;
 
414
    }
 
415
    else
 
416
      max= mid;
 
417
    mid= (min + max) / 2;
 
418
  }
 
419
  res= *(optimizer::QuickRange**)dynamic_array_ptr(&ranges, mid);
 
420
  return (! cmp_next(res) && ! cmp_prev(res));
 
421
}
 
422
 
 
423
 
 
424
int optimizer::QuickRangeSelect::cmp_next(optimizer::QuickRange *range_arg)
 
425
{
 
426
  if (range_arg->flag & NO_MAX_RANGE)
 
427
    return 0;                                   /* key can't be to large */
 
428
 
 
429
  KEY_PART *key_part= key_parts;
 
430
  uint32_t store_length;
 
431
 
 
432
  for (unsigned char *key=range_arg->max_key, *end=key+range_arg->max_length;
 
433
       key < end;
 
434
       key+= store_length, key_part++)
 
435
  {
 
436
    int cmp;
 
437
    store_length= key_part->store_length;
 
438
    if (key_part->null_bit)
 
439
    {
 
440
      if (*key)
 
441
      {
 
442
        if (! key_part->field->is_null())
 
443
          return 1;
 
444
        continue;
 
445
      }
 
446
      else if (key_part->field->is_null())
 
447
        return 0;
 
448
      key++;                                    // Skip null byte
 
449
      store_length--;
 
450
    }
 
451
    if ((cmp= key_part->field->key_cmp(key, key_part->length)) < 0)
 
452
      return 0;
 
453
    if (cmp > 0)
 
454
      return 1;
 
455
  }
 
456
  return (range_arg->flag & NEAR_MAX) ? 1 : 0;          // Exact match
 
457
}
 
458
 
 
459
 
 
460
int optimizer::QuickRangeSelect::cmp_prev(optimizer::QuickRange *range_arg)
 
461
{
 
462
  if (range_arg->flag & NO_MIN_RANGE)
 
463
    return 0; /* key can't be to small */
 
464
 
 
465
  int cmp= key_cmp(key_part_info,
 
466
                   range_arg->min_key,
 
467
                   range_arg->min_length);
 
468
  if (cmp > 0 || (cmp == 0 && (range_arg->flag & NEAR_MIN) == false))
 
469
    return 0;
 
470
  return 1; // outside of range
 
471
}
 
472
 
 
473
 
 
474
void optimizer::QuickRangeSelect::add_info_string(String *str)
 
475
{
 
476
  KEY *key_info= head->key_info + index;
 
477
  str->append(key_info->name);
 
478
}
 
479
 
 
480
 
 
481
void optimizer::QuickRangeSelect::add_keys_and_lengths(String *key_names,
 
482
                                                       String *used_lengths)
 
483
{
 
484
  char buf[64];
 
485
  uint32_t length;
 
486
  KEY *key_info= head->key_info + index;
 
487
  key_names->append(key_info->name);
 
488
  length= internal::int64_t2str(max_used_key_length, buf, 10) - buf;
 
489
  used_lengths->append(buf, length);
 
490
}
 
491
 
 
492
 
 
493
/*
 
494
  This is a hack: we inherit from QUICK_SELECT so that we can use the
 
495
  get_next() interface, but we have to hold a pointer to the original
 
496
  QUICK_SELECT because its data are used all over the place.  What
 
497
  should be done is to factor out the data that is needed into a base
 
498
  class (QUICK_SELECT), and then have two subclasses (_ASC and _DESC)
 
499
  which handle the ranges and implement the get_next() function.  But
 
500
  for now, this seems to work right at least.
 
501
 */
 
502
optimizer::QuickSelectDescending::QuickSelectDescending(optimizer::QuickRangeSelect *q, uint32_t, bool *)
 
503
  :
 
504
    optimizer::QuickRangeSelect(*q)
 
505
{
 
506
  optimizer::QuickRange **pr= (optimizer::QuickRange**) ranges.buffer;
 
507
  optimizer::QuickRange **end_range= pr + ranges.elements;
 
508
  for (; pr != end_range; pr++)
 
509
  {
 
510
    rev_ranges.push_back(*pr);
 
511
  }
 
512
  rev_it= rev_ranges.begin();
 
513
 
 
514
  /* Remove EQ_RANGE flag for keys that are not using the full key */
 
515
  for (vector<optimizer::QuickRange *>::iterator it= rev_ranges.begin();
 
516
       it != rev_ranges.end();
 
517
       ++it)
 
518
  {
 
519
    optimizer::QuickRange *r= *it;
 
520
    if ((r->flag & EQ_RANGE) &&
 
521
        head->key_info[index].key_length != r->max_length)
 
522
    {
 
523
      r->flag&= ~EQ_RANGE;
 
524
    }
 
525
  }
 
526
  q->dont_free= 1; // Don't free shared mem
 
527
  delete q;
 
528
}
 
529
 
 
530
 
 
531
int optimizer::QuickSelectDescending::get_next()
 
532
{
 
533
  /* The max key is handled as follows:
 
534
   *   - if there is NO_MAX_RANGE, start at the end and move backwards
 
535
   *   - if it is an EQ_RANGE, which means that max key covers the entire
 
536
   *     key, go directly to the key and read through it (sorting backwards is
 
537
   *     same as sorting forwards)
 
538
   *   - if it is NEAR_MAX, go to the key or next, step back once, and
 
539
   *     move backwards
 
540
   *   - otherwise (not NEAR_MAX == include the key), go after the key,
 
541
   *     step back once, and move backwards
 
542
   */
 
543
  for (;;)
 
544
  {
 
545
    int result;
 
546
    if (last_range)
 
547
    {                                           // Already read through key
 
548
      result= ((last_range->flag & EQ_RANGE) ?
 
549
                           cursor->index_next_same(record, last_range->min_key,
 
550
                                                                     last_range->min_length) :
 
551
                           cursor->index_prev(record));
 
552
      if (! result)
 
553
      {
 
554
          if (cmp_prev(*(rev_it - 1)) == 0)
 
555
            return 0;
 
556
      }
 
557
      else if (result != HA_ERR_END_OF_FILE)
 
558
        return result;
 
559
    }
 
560
 
 
561
    if (rev_it == rev_ranges.end())
 
562
    {
 
563
      return HA_ERR_END_OF_FILE; // All ranges used
 
564
    }
 
565
    last_range= *rev_it;
 
566
    ++rev_it;
 
567
 
 
568
    if (last_range->flag & NO_MAX_RANGE)        // Read last record
 
569
    {
 
570
      int local_error;
 
571
      if ((local_error= cursor->index_last(record)))
 
572
        return local_error;     // Empty table
 
573
      if (cmp_prev(last_range) == 0)
 
574
        return 0;
 
575
      last_range= 0; // No match; go to next range
 
576
      continue;
 
577
    }
 
578
 
 
579
    if (last_range->flag & EQ_RANGE)
 
580
    {
 
581
      result = cursor->index_read_map(record,
 
582
                                      last_range->max_key,
 
583
                                      last_range->max_keypart_map,
 
584
                                      HA_READ_KEY_EXACT);
 
585
    }
 
586
    else
 
587
    {
 
588
      assert(last_range->flag & NEAR_MAX ||
 
589
             range_reads_after_key(last_range));
 
590
      result= cursor->index_read_map(record,
 
591
                                     last_range->max_key,
 
592
                                     last_range->max_keypart_map,
 
593
                                     ((last_range->flag & NEAR_MAX) ?
 
594
                                      HA_READ_BEFORE_KEY :
 
595
                                      HA_READ_PREFIX_LAST_OR_PREV));
 
596
    }
 
597
    if (result)
 
598
    {
 
599
      if (result != HA_ERR_KEY_NOT_FOUND && result != HA_ERR_END_OF_FILE)
 
600
        return result;
 
601
      last_range= 0;                            // Not found, to next range
 
602
      continue;
 
603
    }
 
604
    if (cmp_prev(last_range) == 0)
 
605
    {
 
606
      if (last_range->flag == (UNIQUE_RANGE | EQ_RANGE))
 
607
        last_range= 0;                          // Stop searching
 
608
      return 0;                         // Found key is in range
 
609
    }
 
610
    last_range= 0;                              // To next range
 
611
  }
 
612
}
 
613
 
 
614
 
 
615
/*
 
616
 * true if this range will require using HA_READ_AFTER_KEY
 
617
   See comment in get_next() about this
 
618
 */
 
619
bool optimizer::QuickSelectDescending::range_reads_after_key(optimizer::QuickRange *range_arg)
 
620
{
 
621
  return ((range_arg->flag & (NO_MAX_RANGE | NEAR_MAX)) ||
 
622
                ! (range_arg->flag & EQ_RANGE) ||
 
623
                head->key_info[index].key_length != range_arg->max_length) ? 1 : 0;
 
624
}
 
625
 
 
626
 
 
627
} /* namespace drizzled */