← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/sel_arg.cc

  • Committer: Monty Taylor
  • Date: 2009-12-08 22:43:58 UTC
  • mfrom: (1240.1.5 build)
  • mto: (1240.1.6 build)
  • mto: This revision was merged to the branch mainline in revision 1241.
  • Revision ID: mordred@inaugust.com-20091208224358-u1pazjsnn4n932cu
Merged up build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/sel_arg.cc
58
58
 
59
59
/* Get overlapping range */
60
60
optimizer::SEL_ARG *optimizer::SEL_ARG::clone_and(optimizer::SEL_ARG *arg)
61
 
{ 
 
61
{
62
62
  unsigned char *new_min= NULL;
63
63
  unsigned char *new_max= NULL;
64
64
  uint8_t flag_min= 0;
75
75
  }
76
76
  if (cmp_max_to_max(arg) <= 0)
77
77
  {
78
 
    new_max= max_value; 
 
78
    new_max= max_value;
79
79
    flag_max= max_flag;
80
80
  }
81
81
  else
82
82
  {
83
 
    new_max= arg->max_value; 
 
83
    new_max= arg->max_value;
84
84
    flag_max= arg->max_flag;
85
85
  }
86
 
  return (new SEL_ARG(field, 
87
 
                      part, 
88
 
                      new_min, 
89
 
                      new_max, 
90
 
                      flag_min, 
 
86
  return (new SEL_ARG(field,
 
87
                      part,
 
88
                      new_min,
 
89
                      new_max,
 
90
                      flag_min,
91
91
                      flag_max,
92
92
                      test(maybe_flag && arg->maybe_flag)));
93
93
}
96
96
/* min <= X , arg->min */
97
97
optimizer::SEL_ARG *optimizer::SEL_ARG::clone_first(optimizer::SEL_ARG *arg)
98
98
{
99
 
  return (new SEL_ARG(field,part, 
100
 
                      min_value, 
 
99
  return (new SEL_ARG(field,part,
 
100
                      min_value,
101
101
                      arg->min_value,
102
 
                      min_flag, 
 
102
                      min_flag,
103
103
                      arg->min_flag & NEAR_MIN ? 0 : NEAR_MAX,
104
104
                                                     maybe_flag | arg->maybe_flag));
105
105
}
108
108
/* min <= X <= key_max */
109
109
optimizer::SEL_ARG *optimizer::SEL_ARG::clone_last(optimizer::SEL_ARG *arg)
110
110
{
111
 
  return (new SEL_ARG(field, 
112
 
                      part, 
113
 
                      min_value, 
 
111
  return (new SEL_ARG(field,
 
112
                      part,
 
113
                      min_value,
114
114
                      arg->max_value,
115
 
                      min_flag, 
116
 
                      arg->max_flag, 
 
115
                      min_flag,
 
116
                      arg->max_flag,
117
117
                      maybe_flag | arg->maybe_flag));
118
118
}
119
119
 
219
219
{
220
220
  optimizer::SEL_ARG *key_tree= first();
221
221
  uint32_t res= key_tree->store_min(key[key_tree->part].store_length,
222
 
                                    range_key, 
 
222
                                    range_key,
223
223
                                    *range_key_flag);
224
224
  *range_key_flag|= key_tree->min_flag;
225
225
 
228
228
      ! (*range_key_flag & (NO_MIN_RANGE | NEAR_MIN)) &&
229
229
      key_tree->next_key_part->type == optimizer::SEL_ARG::KEY_RANGE)
230
230
  {
231
 
    res+= key_tree->next_key_part->store_min_key(key, 
 
231
    res+= key_tree->next_key_part->store_min_key(key,
232
232
                                                 range_key,
233
233
                                                 range_key_flag);
234
234
  }
239
239
{
240
240
  SEL_ARG *key_tree= last();
241
241
  uint32_t res= key_tree->store_max(key[key_tree->part].store_length,
242
 
                                    range_key, 
 
242
                                    range_key,
243
243
                                    *range_key_flag);
244
244
  (*range_key_flag)|= key_tree->max_flag;
245
245
  if (key_tree->next_key_part &&
246
246
      key_tree->next_key_part->part == key_tree->part+1 &&
247
247
      ! (*range_key_flag & (NO_MAX_RANGE | NEAR_MAX)) &&
248
248
      key_tree->next_key_part->type == SEL_ARG::KEY_RANGE)
249
 
    res+= key_tree->next_key_part->store_max_key(key, 
 
249
    res+= key_tree->next_key_part->store_max_key(key,
250
250
                                                 range_key,
251
251
                                                 range_key_flag);
252
252
  return res;
266
266
  min_value= arg.min_value;
267
267
  max_value= arg.max_value;
268
268
  next_key_part= arg.next_key_part;
269
 
  use_count=1; 
 
269
  use_count=1;
270
270
  elements=1;
271
271
}
272
272
 
276
276
  left= right= &optimizer::null_element;
277
277
  color= BLACK;
278
278
  next= prev =0;
279
 
  use_count= 0; 
 
279
  use_count= 0;
280
280
  elements= 1;
281
281
}
282
282
 
284
284
                            const unsigned char *min_value_arg,
285
285
                            const unsigned char *max_value_arg)
286
286
  :
287
 
    min_flag(0), 
288
 
    max_flag(0), 
289
 
    maybe_flag(0), 
 
287
    min_flag(0),
 
288
    max_flag(0),
 
289
    maybe_flag(0),
290
290
    maybe_null(f->real_maybe_null()),
291
 
    elements(1), 
292
 
    use_count(1), 
293
 
    field(f), 
 
291
    elements(1),
 
292
    use_count(1),
 
293
    field(f),
294
294
    min_value((unsigned char*) min_value_arg),
295
 
    max_value((unsigned char*) max_value_arg), 
 
295
    max_value((unsigned char*) max_value_arg),
296
296
    next(0),
297
297
    prev(0),
298
298
    next_key_part(0),
304
304
 
305
305
optimizer::SEL_ARG::SEL_ARG(Field *field_,
306
306
                            uint8_t part_,
307
 
                            unsigned char *min_value_, 
 
307
                            unsigned char *min_value_,
308
308
                            unsigned char *max_value_,
309
309
                            uint8_t min_flag_,
310
310
                            uint8_t max_flag_,
314
314
    max_flag(max_flag_),
315
315
    maybe_flag(maybe_flag_),
316
316
    part(part_),
317
 
    maybe_null(field_->real_maybe_null()), 
 
317
    maybe_null(field_->real_maybe_null()),
318
318
    elements(1),
319
319
    use_count(1),
320
 
    field(field_), 
321
 
    min_value(min_value_), 
 
320
    field(field_),
 
321
    min_value(min_value_),
322
322
    max_value(max_value_),
323
323
    next(0),
324
324
    prev(0),
329
329
  left= right= &optimizer::null_element;
330
330
}
331
331
 
332
 
optimizer::SEL_ARG *optimizer::SEL_ARG::clone(RangeParameter *param, 
 
332
optimizer::SEL_ARG *optimizer::SEL_ARG::clone(RangeParameter *param,
333
333
                                              optimizer::SEL_ARG *new_parent,
334
334
                                              optimizer::SEL_ARG **next_arg)
335
335
{
350
350
  else
351
351
  {
352
352
    if (! (tmp= new (param->mem_root) optimizer::SEL_ARG(field,
353
 
                                                         part, 
 
353
                                                         part,
354
354
                                                         min_value,
355
355
                                                         max_value,
356
 
                                                         min_flag, 
357
 
                                                         max_flag, 
 
356
                                                         min_flag,
 
357
                                                         max_flag,
358
358
                                                         maybe_flag)))
359
359
      return 0; // OOM
360
360
    tmp->parent= new_parent;
576
576
  optimizer::SEL_ARG *par2= NULL;
577
577
  optimizer::SEL_ARG *root= NULL;
578
578
 
579
 
  root= this; 
 
579
  root= this;
580
580
  root->parent= 0;
581
581
 
582
582
  leaf->color= RED;
656
656
        left_rotate(&root, par);
657
657
        w= par->right;
658
658
      }
659
 
      if (w->left->color == optimizer::SEL_ARG::BLACK && 
 
659
      if (w->left->color == optimizer::SEL_ARG::BLACK &&
660
660
          w->right->color == optimizer::SEL_ARG::BLACK)
661
661
      {
662
662
        w->color= optimizer::SEL_ARG::RED;
689
689
        right_rotate(&root, par);
690
690
        w= par->left;
691
691
      }
692
 
      if (w->right->color == optimizer::SEL_ARG::BLACK && 
 
692
      if (w->right->color == optimizer::SEL_ARG::BLACK &&
693
693
          w->left->color == optimizer::SEL_ARG::BLACK)
694
694
      {
695
695
        w->color= optimizer::SEL_ARG::RED;