← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/range.cc

Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/range.cc
237
237
class SEL_IMERGE;
238
238
 
239
239
 
240
 
class SEL_TREE :public Sql_alloc
 
240
class SEL_TREE :public drizzled::memory::SqlAlloc
241
241
{
242
242
public:
243
243
  /*
387
387
  This class relies on memory manager to do the cleanup.
388
388
*/
389
389
 
390
 
class SEL_IMERGE : public Sql_alloc
 
390
class SEL_IMERGE : public drizzled::memory::SqlAlloc
391
391
{
392
392
  enum { PREALLOCED_TREES= 10};
393
393
public:
636
636
  :
637
637
    quick(NULL),
638
638
    cond(NULL),
639
 
    file(static_cast<IO_CACHE *>(sql_calloc(sizeof(IO_CACHE)))),
 
639
    file(static_cast<IO_CACHE *>(memory::sql_calloc(sizeof(IO_CACHE)))),
640
640
    free_cond(false)
641
641
{
642
642
  quick_keys.reset();
923
923
  keys_to_use&= head->keys_in_use_for_query;
924
924
  if (keys_to_use.any())
925
925
  {
926
 
    MEM_ROOT alloc;
 
926
    memory::Root alloc;
927
927
    SEL_TREE *tree= NULL;
928
928
    KEY_PART *key_parts;
929
929
    KEY *key_info;
948
948
    param.force_default_mrr= ordered_output;
949
949
 
950
950
    session->no_errors=1;                               // Don't warn about NULL
951
 
    init_sql_alloc(&alloc, session->variables.range_alloc_block_size, 0);
 
951
    memory::init_sql_alloc(&alloc, session->variables.range_alloc_block_size, 0);
952
952
    if (!(param.key_parts= (KEY_PART*) alloc_root(&alloc,
953
953
                                                  sizeof(KEY_PART)*
954
954
                                                  head->s->key_parts)) ||
2358
2358
}
2359
2359
 
2360
2360
 
2361
 
optimizer::QuickSelectInterface *optimizer::TRP_INDEX_MERGE::make_quick(optimizer::Parameter *param, bool, MEM_ROOT *)
 
2361
optimizer::QuickSelectInterface *optimizer::TRP_INDEX_MERGE::make_quick(optimizer::Parameter *param, bool, memory::Root *)
2362
2362
{
2363
2363
  optimizer::QuickIndexMergeSelect *quick_imerge;
2364
2364
  optimizer::QuickRangeSelect *quick= NULL;
2388
2388
 
2389
2389
optimizer::QuickSelectInterface *optimizer::TRP_ROR_INTERSECT::make_quick(optimizer::Parameter *param,
2390
2390
                                                                          bool retrieve_full_rows,
2391
 
                                                                          MEM_ROOT *parent_alloc)
 
2391
                                                                          memory::Root *parent_alloc)
2392
2392
{
2393
2393
  optimizer::QuickRorIntersectSelect *quick_intersect= NULL;
2394
2394
  optimizer::QuickRangeSelect *quick= NULL;
2395
 
  MEM_ROOT *alloc= NULL;
 
2395
  memory::Root *alloc= NULL;
2396
2396
 
2397
2397
  if ((quick_intersect=
2398
2398
         new optimizer::QuickRorIntersectSelect(param->session,
2441
2441
}
2442
2442
 
2443
2443
 
2444
 
optimizer::QuickSelectInterface *optimizer::TRP_ROR_UNION::make_quick(optimizer::Parameter *param, bool, MEM_ROOT *)
 
2444
optimizer::QuickSelectInterface *optimizer::TRP_ROR_UNION::make_quick(optimizer::Parameter *param, bool, memory::Root *)
2445
2445
{
2446
2446
  optimizer::QuickRorUnionSelect *quick_roru= NULL;
2447
2447
  optimizer::TABLE_READ_PLAN **scan= NULL;
2626
2626
          * Otherwise, don't produce a SEL_TREE.
2627
2627
        */
2628
2628
#define NOT_IN_IGNORE_THRESHOLD 1000
2629
 
        MEM_ROOT *tmp_root= param->mem_root;
 
2629
        memory::Root *tmp_root= param->mem_root;
2630
2630
        param->session->mem_root= param->old_root;
2631
2631
        /*
2632
2632
          Create one Item_type constant object. We'll need it as
2937
2937
      all the memory allocated has the same life span as the subselect
2938
2938
      item itself. So we have to restore the thread's mem_root here.
2939
2939
    */
2940
 
    MEM_ROOT *tmp_root= param->mem_root;
 
2940
    memory::Root *tmp_root= param->mem_root;
2941
2941
    param->session->mem_root= param->old_root;
2942
2942
    tree= cond->val_int() ? new(tmp_root) SEL_TREE(SEL_TREE::ALWAYS) :
2943
2943
                            new(tmp_root) SEL_TREE(SEL_TREE::IMPOSSIBLE);
3115
3115
  uint32_t maybe_null=(uint32_t) field->real_maybe_null();
3116
3116
  bool optimize_range;
3117
3117
  optimizer::SEL_ARG *tree= NULL;
3118
 
  MEM_ROOT *alloc= param->mem_root;
 
3118
  memory::Root *alloc= param->mem_root;
3119
3119
  unsigned char *str;
3120
3120
  int err= 0;
3121
3121
 
4772
4772
                            optimizer::SEL_ARG *key_tree,
4773
4773
                            uint32_t mrr_flags,
4774
4774
                            uint32_t mrr_buf_size,
4775
 
                            MEM_ROOT *parent_alloc)
 
4775
                            memory::Root *parent_alloc)
4776
4776
{
4777
4777
  optimizer::QuickRangeSelect *quick= NULL;
4778
4778
  bool create_err= false;
5033
5033
                                                                 table_reference_st *ref,
5034
5034
                                                                 ha_rows records)
5035
5035
{
5036
 
  MEM_ROOT *old_root, *alloc;
 
5036
  memory::Root *old_root, *alloc;
5037
5037
  optimizer::QuickRangeSelect *quick= NULL;
5038
5038
  KEY *key_info = &table->key_info[ref->key];
5039
5039
  KEY_PART *key_part;
6258
6258
    NULL otherwise.
6259
6259
*/
6260
6260
optimizer::QuickSelectInterface *
6261
 
optimizer::TRP_GROUP_MIN_MAX::make_quick(optimizer::Parameter *param, bool, MEM_ROOT *parent_alloc)
 
6261
optimizer::TRP_GROUP_MIN_MAX::make_quick(optimizer::Parameter *param, bool, memory::Root *parent_alloc)
6262
6262
{
6263
6263
  optimizer::QuickGroupMinMaxSelect *quick= NULL;
6264
6264
 
6346
6346
}
6347
6347
 
6348
6348
 
6349
 
optimizer::QuickSelectInterface *optimizer::TRP_RANGE::make_quick(optimizer::Parameter *param, bool, MEM_ROOT *parent_alloc)
 
6349
optimizer::QuickSelectInterface *optimizer::TRP_RANGE::make_quick(optimizer::Parameter *param, bool, memory::Root *parent_alloc)
6350
6350
{
6351
6351
  optimizer::QuickRangeSelect *quick= NULL;
6352
6352
  if ((quick= optimizer::get_quick_select(param,