← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_cmpfunc.cc

  • Committer: Monty Taylor
  • Date: 2008-09-22 23:53:43 UTC
  • mto: This revision was merged to the branch mainline in revision 417.
  • Revision ID: monty@inaugust.com-20080922235343-ihqvp6g9k1mtzxmc
Renamed max/min.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_cmpfunc.cc
590
590
  {
591
591
    if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
592
592
    {
593
 
      precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
 
593
      precision= 5 / log_10[cmax((*a)->decimals, (*b)->decimals) + 1];
594
594
      if (func == &Arg_comparator::compare_real)
595
595
        func= &Arg_comparator::compare_real_fixed;
596
596
      else if (func == &Arg_comparator::compare_e_real)
1081
1081
      owner->null_value= 0;
1082
1082
      uint res1_length= res1->length();
1083
1083
      uint res2_length= res2->length();
1084
 
      int cmp= memcmp(res1->ptr(), res2->ptr(), min(res1_length,res2_length));
 
1084
      int cmp= memcmp(res1->ptr(), res2->ptr(), cmin(res1_length,res2_length));
1085
1085
      return cmp ? cmp : (int) (res1_length - res2_length);
1086
1086
    }
1087
1087
  }
2166
2166
{
2167
2167
  agg_result_type(&hybrid_type, args, 2);
2168
2168
  maybe_null=args[1]->maybe_null;
2169
 
  decimals= max(args[0]->decimals, args[1]->decimals);
 
2169
  decimals= cmax(args[0]->decimals, args[1]->decimals);
2170
2170
  unsigned_flag= args[0]->unsigned_flag && args[1]->unsigned_flag;
2171
2171
 
2172
2172
  if (hybrid_type == DECIMAL_RESULT || hybrid_type == INT_RESULT) 
2177
2177
    int len1= args[1]->max_length - args[1]->decimals
2178
2178
      - (args[1]->unsigned_flag ? 0 : 1);
2179
2179
 
2180
 
    max_length= max(len0, len1) + decimals + (unsigned_flag ? 0 : 1);
 
2180
    max_length= cmax(len0, len1) + decimals + (unsigned_flag ? 0 : 1);
2181
2181
  }
2182
2182
  else
2183
 
    max_length= max(args[0]->max_length, args[1]->max_length);
 
2183
    max_length= cmax(args[0]->max_length, args[1]->max_length);
2184
2184
 
2185
2185
  switch (hybrid_type) {
2186
2186
  case STRING_RESULT:
2202
2202
 
2203
2203
uint Item_func_ifnull::decimal_precision() const
2204
2204
{
2205
 
  int max_int_part=max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
2206
 
  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
 
2205
  int max_int_part=cmax(args[0]->decimal_int_part(),args[1]->decimal_int_part());
 
2206
  return cmin(max_int_part + decimals, DECIMAL_MAX_PRECISION);
2207
2207
}
2208
2208
 
2209
2209
 
2331
2331
Item_func_if::fix_length_and_dec()
2332
2332
{
2333
2333
  maybe_null=args[1]->maybe_null || args[2]->maybe_null;
2334
 
  decimals= max(args[1]->decimals, args[2]->decimals);
 
2334
  decimals= cmax(args[1]->decimals, args[2]->decimals);
2335
2335
  unsigned_flag=args[1]->unsigned_flag && args[2]->unsigned_flag;
2336
2336
 
2337
2337
  enum Item_result arg1_type=args[1]->result_type();
2375
2375
    int len2= args[2]->max_length - args[2]->decimals
2376
2376
      - (args[2]->unsigned_flag ? 0 : 1);
2377
2377
 
2378
 
    max_length=max(len1, len2) + decimals + (unsigned_flag ? 0 : 1);
 
2378
    max_length=cmax(len1, len2) + decimals + (unsigned_flag ? 0 : 1);
2379
2379
  }
2380
2380
  else
2381
 
    max_length= max(args[1]->max_length, args[2]->max_length);
 
2381
    max_length= cmax(args[1]->max_length, args[2]->max_length);
2382
2382
}
2383
2383
 
2384
2384
 
2385
2385
uint Item_func_if::decimal_precision() const
2386
2386
{
2387
 
  int precision=(max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
 
2387
  int precision=(cmax(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
2388
2388
                 decimals);
2389
 
  return min(precision, DECIMAL_MAX_PRECISION);
 
2389
  return cmin(precision, DECIMAL_MAX_PRECISION);
2390
2390
}
2391
2391
 
2392
2392
 
2791
2791
 
2792
2792
  if (else_expr_num != -1) 
2793
2793
    set_if_bigger(max_int_part, args[else_expr_num]->decimal_int_part());
2794
 
  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
 
2794
  return cmin(max_int_part + decimals, DECIMAL_MAX_PRECISION);
2795
2795
}
2796
2796
 
2797
2797
 
4541
4541
      else
4542
4542
      {
4543
4543
        if (i < g)
4544
 
          g = i; // g = min(i, g)
 
4544
          g = i; // g = cmin(i, g)
4545
4545
        f = i;
4546
4546
        while (g >= 0 && pattern[g] == pattern[g + plm1 - f])
4547
4547
          g--;
4560
4560
      else
4561
4561
      {
4562
4562
        if (i < g)
4563
 
          g = i; // g = min(i, g)
 
4563
          g = i; // g = cmin(i, g)
4564
4564
        f = i;
4565
4565
        while (g >= 0 &&
4566
4566
               likeconv(cs, pattern[g]) == likeconv(cs, pattern[g + plm1 - f]))
4688
4688
      else
4689
4689
      {
4690
4690
        if (turboShift < bcShift)
4691
 
          shift = max(shift, u + 1);
 
4691
          shift = cmax(shift, u + 1);
4692
4692
        u = 0;
4693
4693
      }
4694
4694
      j+= shift;
4713
4713
      turboShift = u - v;
4714
4714
      bcShift    = bmBc[(uint) likeconv(cs, text[i + j])] - plm1 + i;
4715
4715
      shift      = (turboShift > bcShift) ? turboShift : bcShift;
4716
 
      shift      = max(shift, bmGs[i]);
 
4716
      shift      = cmax(shift, bmGs[i]);
4717
4717
      if (shift == bmGs[i])
4718
4718
        u = (pattern_len - shift < v) ? pattern_len - shift : v;
4719
4719
      else
4720
4720
      {
4721
4721
        if (turboShift < bcShift)
4722
 
          shift = max(shift, u + 1);
 
4722
          shift = cmax(shift, u + 1);
4723
4723
        u = 0;
4724
4724
      }
4725
4725
      j+= shift;