← 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-11-19 19:42:44 UTC
  • mto: (1945.2.1 quick)
  • mto: This revision was merged to the branch mainline in revision 1944.
  • Revision ID: brian@tangent.org-20101119194244-7vx6u5vwzvu9uvex
Remove dead getShare() call which should have been a call on the cache
directly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/quick_range_select.cc
21
21
#include "drizzled/session.h"
22
22
#include "drizzled/optimizer/quick_range.h"
23
23
#include "drizzled/optimizer/quick_range_select.h"
24
 
#include "drizzled/sql_bitmap.h"
25
24
#include "drizzled/internal/m_string.h"
26
25
#include <fcntl.h>
27
 
#include "drizzled/memory/multi_malloc.h"
28
26
 
29
27
using namespace std;
30
28
 
36
34
                                              Table *table,
37
35
                                              uint32_t key_nr,
38
36
                                              bool no_alloc,
39
 
                                              memory::Root *parent_alloc,
40
 
                                              bool *create_error)
 
37
                                              memory::Root *parent_alloc)
41
38
  :
42
 
    mrr_flags(0),
43
 
    alloc(),
44
39
    cursor(NULL),
45
40
    ranges(),
46
41
    in_ror_merged_scan(false),
47
 
    column_bitmap(),
 
42
    column_bitmap(NULL),
48
43
    save_read_set(NULL),
49
44
    save_write_set(NULL),
50
45
    free_file(false),
52
47
    last_range(NULL),
53
48
    qr_traversal_ctx(),
54
49
    mrr_buf_size(0),
55
 
    mrr_buf_desc(NULL),
56
50
    key_parts(NULL),
57
 
    dont_free(false)
 
51
    dont_free(false),
 
52
    mrr_flags(0),
 
53
    alloc()
58
54
{
59
 
  my_bitmap_map *bitmap= NULL;
60
 
 
61
55
  sorted= 0;
62
56
  index= key_nr;
63
57
  head= table;
66
60
 
67
61
  /* 'session' is not accessible in QuickRangeSelect::reset(). */
68
62
  mrr_buf_size= session->variables.read_rnd_buff_size;
69
 
  mrr_buf_desc= NULL;
70
63
 
71
64
  if (! no_alloc && ! parent_alloc)
72
65
  {
83
76
  record= head->record[0];
84
77
  save_read_set= head->read_set;
85
78
  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
 
  }
 
79
  column_bitmap= new boost::dynamic_bitset<>(table->getShare()->sizeFields());
102
80
}
103
81
 
104
82
 
106
84
{
107
85
  if (cursor->inited != Cursor::NONE)
108
86
    cursor->ha_index_or_rnd_end();
109
 
  return (cursor->ha_index_init(index, 1));
 
87
  return (cursor->startIndexScan(index, 1));
110
88
}
111
89
 
112
90
 
138
116
      }
139
117
    }
140
118
    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
 
  }
 
119
    delete column_bitmap;
 
120
    alloc.free_root(MYF(0));
 
121
  }
 
122
  head->column_bitmaps_set(*save_read_set, *save_write_set);
149
123
}
150
124
 
151
125
 
161
135
    {
162
136
      return 0;
163
137
    }
164
 
    head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
138
    head->column_bitmaps_set(*column_bitmap, *column_bitmap);
165
139
    goto end;
166
140
  }
167
141
 
187
161
    goto failure;
188
162
  }
189
163
 
190
 
  head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
164
  head->column_bitmaps_set(*column_bitmap, *column_bitmap);
191
165
 
192
166
  if (cursor->ha_external_lock(session, F_RDLCK))
193
167
    goto failure;
218
192
  }
219
193
  head->prepare_for_position();
220
194
  head->cursor= org_file;
221
 
  column_bitmap= *head->read_set;
222
 
  head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
195
  *column_bitmap|= *head->read_set;
 
196
  head->column_bitmaps_set(*column_bitmap, *column_bitmap);
223
197
 
224
198
  return 0;
225
199
 
226
200
failure:
227
 
  head->column_bitmaps_set(save_read_set, save_write_set);
 
201
  head->column_bitmaps_set(*save_read_set, *save_write_set);
228
202
  delete cursor;
229
203
  cursor= save_file;
230
204
  return 0;
244
218
    optimizer::QuickRange *tmp= *((optimizer::QuickRange**)ranges.buffer);
245
219
    if ((tmp->flag & (EQ_RANGE | NULL_RANGE)) == EQ_RANGE)
246
220
    {
247
 
      KEY *key=head->key_info+index;
 
221
      KeyInfo *key=head->key_info+index;
248
222
      return ((key->flags & (HA_NOSAME)) == HA_NOSAME &&
249
223
              key->key_length == tmp->min_length);
250
224
    }
255
229
 
256
230
int optimizer::QuickRangeSelect::reset()
257
231
{
258
 
  uint32_t buf_size= 0;
259
 
  unsigned char *mrange_buff= NULL;
260
232
  int error= 0;
261
 
  HANDLER_BUFFER empty_buf;
262
233
  last_range= NULL;
263
234
  cur_range= (optimizer::QuickRange**) ranges.buffer;
264
235
 
265
 
  if (cursor->inited == Cursor::NONE && (error= cursor->ha_index_init(index, 1)))
 
236
  if (cursor->inited == Cursor::NONE && (error= cursor->startIndexScan(index, 1)))
266
237
  {
267
238
    return error;
268
239
  }
269
240
 
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
 
  }
 
241
  /*
 
242
    (in the past) Allocate buffer if we need one but haven't allocated it yet 
 
243
    There is a later assert in th code that hoped to catch random free() that might
 
244
    have done this.
 
245
  */
 
246
  assert(not (mrr_buf_size));
301
247
 
302
248
  if (sorted)
303
249
  {
310
256
  error= cursor->multi_range_read_init(&seq_funcs,
311
257
                                       (void*) this,
312
258
                                       ranges.elements,
313
 
                                       mrr_flags,
314
 
                                       mrr_buf_desc ? mrr_buf_desc : &empty_buf);
 
259
                                       mrr_flags);
315
260
  return error;
316
261
}
317
262
 
325
270
      We don't need to signal the bitmap change as the bitmap is always the
326
271
      same for this head->cursor
327
272
    */
328
 
    head->column_bitmaps_set(&column_bitmap, &column_bitmap);
 
273
    head->column_bitmaps_set(*column_bitmap, *column_bitmap);
329
274
  }
330
275
 
331
276
  int result= cursor->multi_range_read_next(&dummy);
333
278
  if (in_ror_merged_scan)
334
279
  {
335
280
    /* Restore bitmaps set on entry */
336
 
    head->column_bitmaps_set(save_read_set, save_write_set);
 
281
    head->column_bitmaps_set(*save_read_set, *save_write_set);
337
282
  }
338
283
  return result;
339
284
}
473
418
 
474
419
void optimizer::QuickRangeSelect::add_info_string(String *str)
475
420
{
476
 
  KEY *key_info= head->key_info + index;
 
421
  KeyInfo *key_info= head->key_info + index;
477
422
  str->append(key_info->name);
478
423
}
479
424
 
483
428
{
484
429
  char buf[64];
485
430
  uint32_t length;
486
 
  KEY *key_info= head->key_info + index;
 
431
  KeyInfo *key_info= head->key_info + index;
487
432
  key_names->append(key_info->name);
488
433
  length= internal::int64_t2str(max_used_key_length, buf, 10) - buf;
489
434
  used_lengths->append(buf, length);