← 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: Stewart Smith
  • Date: 2010-03-02 06:41:59 UTC
  • mto: (1309.2.13 build)
  • mto: This revision was merged to the branch mainline in revision 1318.
  • Revision ID: stewart@flamingspork.com-20100302064159-gktw6hcbs3u0fflm
move Item_result out to its own header file and out of common.h

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