← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/quick_range_select.cc

  • Committer: Brian Aker
  • Date: 2010-05-15 01:19:45 UTC
  • Revision ID: brian@gaz-20100515011945-uxhf94vi0tzm0vq6
Rename of KEY to KeyInfo

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/quick_range_select.cc
24
24
#include "drizzled/sql_bitmap.h"
25
25
#include "drizzled/internal/m_string.h"
26
26
#include <fcntl.h>
27
 
#include "drizzled/memory/multi_malloc.h"
28
27
 
29
28
using namespace std;
30
29
 
39
38
                                              memory::Root *parent_alloc,
40
39
                                              bool *create_error)
41
40
  :
42
 
    mrr_flags(0),
43
 
    alloc(),
44
41
    cursor(NULL),
45
42
    ranges(),
46
43
    in_ror_merged_scan(false),
54
51
    mrr_buf_size(0),
55
52
    mrr_buf_desc(NULL),
56
53
    key_parts(NULL),
57
 
    dont_free(false)
 
54
    dont_free(false),
 
55
    mrr_flags(0),
 
56
    alloc()
58
57
{
59
58
  my_bitmap_map *bitmap= NULL;
60
59
 
106
105
{
107
106
  if (cursor->inited != Cursor::NONE)
108
107
    cursor->ha_index_or_rnd_end();
109
 
  return (cursor->ha_index_init(index, 1));
 
108
  return (cursor->startIndexScan(index, 1));
110
109
}
111
110
 
112
111
 
138
137
      }
139
138
    }
140
139
    delete_dynamic(&ranges); /* ranges are allocated in alloc */
141
 
    free_root(&alloc,MYF(0));
 
140
    alloc.free_root(MYF(0));
142
141
  }
143
142
  head->column_bitmaps_set(save_read_set, save_write_set);
144
143
  assert(mrr_buf_desc == NULL);
244
243
    optimizer::QuickRange *tmp= *((optimizer::QuickRange**)ranges.buffer);
245
244
    if ((tmp->flag & (EQ_RANGE | NULL_RANGE)) == EQ_RANGE)
246
245
    {
247
 
      KEY *key=head->key_info+index;
 
246
      KeyInfo *key=head->key_info+index;
248
247
      return ((key->flags & (HA_NOSAME)) == HA_NOSAME &&
249
248
              key->key_length == tmp->min_length);
250
249
    }
255
254
 
256
255
int optimizer::QuickRangeSelect::reset()
257
256
{
258
 
  uint32_t buf_size= 0;
259
 
  unsigned char *mrange_buff= NULL;
260
257
  int error= 0;
261
 
  HANDLER_BUFFER empty_buf;
262
258
  last_range= NULL;
263
259
  cur_range= (optimizer::QuickRange**) ranges.buffer;
264
260
 
265
 
  if (cursor->inited == Cursor::NONE && (error= cursor->ha_index_init(index, 1)))
 
261
  if (cursor->inited == Cursor::NONE && (error= cursor->startIndexScan(index, 1)))
266
262
  {
267
263
    return error;
268
264
  }
269
265
 
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
 
  }
 
266
  /*
 
267
    (in the past) Allocate buffer if we need one but haven't allocated it yet 
 
268
    There is a later assert in th code that hoped to catch random free() that might
 
269
    have done this.
 
270
  */
 
271
  assert(not (mrr_buf_size && ! mrr_buf_desc));
301
272
 
302
273
  if (sorted)
303
274
  {
310
281
  error= cursor->multi_range_read_init(&seq_funcs,
311
282
                                       (void*) this,
312
283
                                       ranges.elements,
313
 
                                       mrr_flags,
314
 
                                       mrr_buf_desc ? mrr_buf_desc : &empty_buf);
 
284
                                       mrr_flags);
315
285
  return error;
316
286
}
317
287
 
473
443
 
474
444
void optimizer::QuickRangeSelect::add_info_string(String *str)
475
445
{
476
 
  KEY *key_info= head->key_info + index;
 
446
  KeyInfo *key_info= head->key_info + index;
477
447
  str->append(key_info->name);
478
448
}
479
449
 
483
453
{
484
454
  char buf[64];
485
455
  uint32_t length;
486
 
  KEY *key_info= head->key_info + index;
 
456
  KeyInfo *key_info= head->key_info + index;
487
457
  key_names->append(key_info->name);
488
458
  length= internal::int64_t2str(max_used_key_length, buf, 10) - buf;
489
459
  used_lengths->append(buf, length);