~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/range.cc

Committer: Olaf van der Spek
Date: 2011-06-22 14:19:44 UTC
mto: This revision was merged to the branch mainline in revision 2347.
Revision ID: olafvdspek@gmail.com-20110622141944-na0vb0uv30n6u55z

Refactor

Show diffs side-by-side

added added

removed removed

drizzled/optimizer/range.cc

696

697

session->no_errors=1; // Don't warn about NULL

698

alloc.init(session->variables.range_alloc_block_size);

699

param.key_parts= (KEY_PART*) alloc.alloc_root( sizeof(KEY_PART) * head->getShare()->key_parts);

699

param.key_parts= (KEY_PART*) alloc.alloc( sizeof(KEY_PART) * head->getShare()->key_parts);

700

if (fill_used_fields_bitmap(&param))

701

{

702

session->no_errors=0;

979

ha_rows roru_total_records;

980

double roru_intersect_part= 1.0;

981

982

if (! (range_scans= (optimizer::RangeReadPlan**)param->mem_root->alloc_root(sizeof(optimizer::RangeReadPlan*)* n_child_scans)))

983

{

984

return NULL;

985

}

982

range_scans= (optimizer::RangeReadPlan**)param->mem_root->alloc_root(sizeof(optimizer::RangeReadPlan*)* n_child_scans);

986

983

987

984

988

985

Collect best 'range' scan for each of disjuncts, and, while doing so,

989

986

analyze possibility of ROR scans. Also calculate some values needed by

990

987

other parts of the code.

991

988

992

for (ptree= imerge->trees, cur_child= range_scans;

993

ptree != imerge->trees_next;

994

ptree++, cur_child++)

989

for (ptree= imerge->trees, cur_child= range_scans; ptree != imerge->trees_next; ptree++, cur_child++)

995

990

{

996

991

if (!(*cur_child= get_key_scans_params(session, param, *ptree, true, false, read_time)))

997

992

{

1062

1057

param->session->variables.sortbuff_size);

1063

1058

if (param->imerge_cost_buff_size < unique_calc_buff_size)

1064

1059

{

1065

if (!(param->imerge_cost_buff= (uint*)param->mem_root->alloc_root(unique_calc_buff_size)))

1066

{

1067

return NULL;

1068

}

1069

1060

param->imerge_cost_buff= (uint*)param->mem_root->alloc(unique_calc_buff_size);

1070

1061

param->imerge_cost_buff_size= unique_calc_buff_size;

1071

1062

}

1072

1063

1094

1085

1095

1086

/* Ok, it is possible to build a ROR-union, try it. */

1096

1087

bool dummy;

1097

if (! (roru_read_plans=

1098

(optimizer::TableReadPlan **) param->mem_root->alloc_root(sizeof(optimizer::TableReadPlan*) * n_child_scans)))

1099

{

1100

return imerge_trp;

1101

}

1088

roru_read_plans= (optimizer::TableReadPlan **) param->mem_root->alloc(sizeof(optimizer::TableReadPlan*) * n_child_scans);

1102

1089

skip_to_ror_scan:

1103

1090

roru_index_costs= 0.0;

1104

1091

roru_total_records= 0;

1209

1196

static

1210

1197

optimizer::RorScanInfo *make_ror_scan(const optimizer::Parameter *param, int idx, optimizer::SEL_ARG *sel_arg)

1211

1198

{

1212

optimizer::RorScanInfo *ror_scan= NULL;

1213

1214

1199

uint32_t keynr;

1215

1216

if (!(ror_scan= (optimizer::RorScanInfo*)param->mem_root->alloc_root(sizeof(optimizer::RorScanInfo))))

1217

return NULL;

1200

optimizer::RorScanInfo* ror_scan= (optimizer::RorScanInfo*)param->mem_root->alloc(sizeof(optimizer::RorScanInfo));

1218

1201

1219

1202

ror_scan->idx= idx;

1220

1203

ror_scan->keynr= keynr= param->real_keynr[idx];

1711

1694

if (total_cost > read_time)

1712

1695

return NULL;

1713

1696

1714

optimizer::RorIntersectReadPlan *trp= NULL;

1715

if (! (trp= new (param->mem_root) optimizer::RorIntersectReadPlan))

1716

{

1717

return trp;

1718

}

1697

optimizer::RorIntersectReadPlan* trp= new (param->mem_root) optimizer::RorIntersectReadPlan;

1719

1698

1720

1699

uint32_t best_num= (ror_scan_mark - tree->ror_scans);

1721

if (!(trp->first_scan= (optimizer::RorScanInfo**)param->mem_root->alloc_root(sizeof(optimizer::RorScanInfo*)* best_num)))

1722

return NULL;

1700

trp->first_scan= (optimizer::RorScanInfo**)param->mem_root->alloc(sizeof(optimizer::RorScanInfo*)* best_num);

1723

1701

memcpy(trp->first_scan, tree->ror_scans, best_num*sizeof(optimizer::RorScanInfo*));

1724

1702

trp->last_scan= trp->first_scan + best_num;

1725

1703

trp->is_covering= true;

1817

1795

uint32_t cpk_no= 0;

1818

1796

bool cpk_scan_used= false;

1819

1797

1820

if (! (tree->ror_scans= (optimizer::RorScanInfo**)param->mem_root->alloc_root(sizeof(optimizer::RorScanInfo*)* param->keys)))

1821

{

1822

return NULL;

1823

}

1824

cpk_no= ((param->table->cursor->primary_key_is_clustered()) ?

1825

param->table->getShare()->getPrimaryKey() : MAX_KEY);

1798

tree->ror_scans= (optimizer::RorScanInfo**)param->mem_root->alloc(sizeof(optimizer::RorScanInfo*)* param->keys);

1799

cpk_no= ((param->table->cursor->primary_key_is_clustered()) ? param->table->getShare()->getPrimaryKey() : MAX_KEY);

1826

1800

1827

1801

for (idx= 0, cur_ror_scan= tree->ror_scans; idx < param->keys; idx++)

1828

1802

{

1850

1824

(qsort_cmp)cmp_ror_scan_info);

1851

1825

1852

1826

optimizer::RorScanInfo **intersect_scans= NULL; /* ROR scans used in index intersection */

1853

optimizer::RorScanInfo **intersect_scans_end= NULL;

1854

if (! (intersect_scans= (optimizer::RorScanInfo**)param->mem_root->alloc_root(sizeof(optimizer::RorScanInfo*) * tree->n_ror_scans)))

1855

return NULL;

1827

optimizer::RorScanInfo **intersect_scans_end= intersect_scans=

1828

(optimizer::RorScanInfo**)param->mem_root->alloc(sizeof(optimizer::RorScanInfo*) * tree->n_ror_scans);

1856

1829

intersect_scans_end= intersect_scans;

1857

1830

1858

1831

/* Create and incrementally update ROR intersection. */

1911

1884

optimizer::RorIntersectReadPlan *trp= NULL;

1912

1885

if (min_cost < read_time && (cpk_scan_used || best_num > 1))

1913

1886

{

1914

if (! (trp= new (param->mem_root) optimizer::RorIntersectReadPlan))

1915

return trp;

1916

1917

if (! (trp->first_scan=

1918

(optimizer::RorScanInfo**)param->mem_root->alloc_root(sizeof(optimizer::RorScanInfo*)*best_num)))

1919

return NULL;

1887

trp= new (param->mem_root) optimizer::RorIntersectReadPlan;

1888

trp->first_scan= (optimizer::RorScanInfo**)param->mem_root->alloc(sizeof(optimizer::RorScanInfo*)*best_num);

1920

1889

memcpy(trp->first_scan, intersect_scans, best_num*sizeof(optimizer::RorScanInfo*));

1921

1890

trp->last_scan= trp->first_scan + best_num;

1922

1891

trp->is_covering= intersect_best.is_covering;

2902

2871

field_length= length;

2903

2872

}

2904

2873

length+=offset;

2905

if (!(min_str= (unsigned char*) alloc->alloc_root(length*2)))

2906

{

2907

goto end;

2908

}

2909

2874

min_str= (unsigned char*) alloc->alloc(length*2);

2910

2875

max_str=min_str+length;

2911

2876

if (maybe_null)

2912

2877

max_str[0]= min_str[0]=0;

3142

3107

goto end;

3143

3108

}

3144

3109

3145

str= (unsigned char*) alloc->alloc_root(key_part->store_length+1);

3146

if (!str)

3147

goto end;

3110

str= (unsigned char*) alloc->alloc(key_part->store_length+1);

3148

3111

if (maybe_null)

3149

3112

*str= (unsigned char) field->is_real_null(); // Set to 1 if null

3150

3113

field->get_key_image(str+maybe_null, key_part->length);

4276

4239

range->min_length= range->max_length= ref->key_length;

4277

4240

range->min_keypart_map= range->max_keypart_map=

4278

4241

make_prev_keypart_map(ref->key_parts);

4279

range->flag= ((ref->key_length == key_info->key_length &&

4280

(key_info->flags & HA_END_SPACE_KEY) == 0) ? EQ_RANGE : 0);

4281

4282

4283

if (!(quick->key_parts=key_part=(KEY_PART *)

4284

quick->alloc.alloc_root(sizeof(KEY_PART)*ref->key_parts)))

4285

goto err;

4242

range->flag= (ref->key_length == key_info->key_length && (key_info->flags & HA_END_SPACE_KEY) == 0) ? EQ_RANGE : 0;

4243

4244

quick->key_parts=key_part=(KEY_PART *)quick->alloc.alloc_root(sizeof(KEY_PART)*ref->key_parts);

4286

4245

4287

4246

for (part=0 ; part < ref->key_parts ;part++,key_part++)

4288

4247

{

Older »