← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.cc

  • Committer: Brian Aker
  • Date: 2010-12-25 00:28:49 UTC
  • mto: This revision was merged to the branch mainline in revision 2031.
  • Revision ID: brian@tangent.org-20101225002849-g73mg6ihulajis0o
First pass in refactoring of the name of my_decimal.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.cc
1182
1182
    if (!(*b)->null_value)
1183
1183
    {
1184
1184
      owner->null_value= 0;
1185
 
      return my_decimal_cmp(val1, val2);
 
1185
      return class_decimal_cmp(val1, val2);
1186
1186
    }
1187
1187
  }
1188
1188
  owner->null_value= 1;
1205
1205
  my_decimal *val2= (*b)->val_decimal(&value2);
1206
1206
  if ((*a)->null_value || (*b)->null_value)
1207
1207
    return test((*a)->null_value && (*b)->null_value);
1208
 
  return test(my_decimal_cmp(val1, val2) == 0);
 
1208
  return test(class_decimal_cmp(val1, val2) == 0);
1209
1209
}
1210
1210
 
1211
1211
 
1906
1906
        and we are comparing against a decimal
1907
1907
      */
1908
1908
      if (dec && range->type == DECIMAL_RESULT)
1909
 
        cmp_result= my_decimal_cmp(&range->dec, dec) <= 0;
 
1909
        cmp_result= class_decimal_cmp(&range->dec, dec) <= 0;
1910
1910
      else
1911
1911
        cmp_result= (range->dbl <= value);
1912
1912
      if (cmp_result)
1916
1916
    }
1917
1917
    interval_range *range= intervals+start;
1918
1918
    return ((dec && range->type == DECIMAL_RESULT) ?
1919
 
            my_decimal_cmp(dec, &range->dec) < 0 :
 
1919
            class_decimal_cmp(dec, &range->dec) < 0 :
1920
1920
            value < range->dbl) ? 0 : start + 1;
1921
1921
  }
1922
1922
 
1931
1931
      /* Skip NULL ranges. */
1932
1932
      if (el->null_value)
1933
1933
        continue;
1934
 
      if (my_decimal_cmp(e_dec, dec) > 0)
 
1934
      if (class_decimal_cmp(e_dec, dec) > 0)
1935
1935
        return i - 1;
1936
1936
    }
1937
1937
    else
2135
2135
    a_dec= args[1]->val_decimal(&a_buf);
2136
2136
    b_dec= args[2]->val_decimal(&b_buf);
2137
2137
    if (!args[1]->null_value && !args[2]->null_value)
2138
 
      return (int64_t) ((my_decimal_cmp(dec, a_dec) >= 0 &&
2139
 
                          my_decimal_cmp(dec, b_dec) <= 0) != negated);
 
2138
      return (int64_t) ((class_decimal_cmp(dec, a_dec) >= 0 &&
 
2139
                          class_decimal_cmp(dec, b_dec) <= 0) != negated);
2140
2140
    if (args[1]->null_value && args[2]->null_value)
2141
2141
      null_value=1;
2142
2142
    else if (args[1]->null_value)
2143
 
      null_value= (my_decimal_cmp(dec, b_dec) <= 0);
 
2143
      null_value= (class_decimal_cmp(dec, b_dec) <= 0);
2144
2144
    else
2145
 
      null_value= (my_decimal_cmp(dec, a_dec) >= 0);
 
2145
      null_value= (class_decimal_cmp(dec, a_dec) >= 0);
2146
2146
  }
2147
2147
  else
2148
2148
  {
2720
2720
 
2721
2721
void Item_func_case::agg_num_lengths(Item *arg)
2722
2722
{
2723
 
  uint32_t len= my_decimal_length_to_precision(arg->max_length, arg->decimals,
 
2723
  uint32_t len= class_decimal_length_to_precision(arg->max_length, arg->decimals,
2724
2724
                                           arg->unsigned_flag) - arg->decimals;
2725
2725
  set_if_bigger(max_length, len);
2726
2726
  set_if_bigger(decimals, arg->decimals);
2803
2803
      agg_num_lengths(args[i + 1]);
2804
2804
    if (else_expr_num != -1)
2805
2805
      agg_num_lengths(args[else_expr_num]);
2806
 
    max_length= my_decimal_precision_to_length(max_length + decimals, decimals,
 
2806
    max_length= class_decimal_precision_to_length(max_length + decimals, decimals,
2807
2807
                                               unsigned_flag);
2808
2808
  }
2809
2809
}
3073
3073
  */
3074
3074
  a->fix_buffer_pointer();
3075
3075
  b->fix_buffer_pointer();
3076
 
  return my_decimal_cmp(a, b);
 
3076
  return class_decimal_cmp(a, b);
3077
3077
}
3078
3078
 
3079
3079
 
3432
3432
  my_decimal tmp_buf, *tmp= arg->val_decimal(&tmp_buf);
3433
3433
  if (arg->null_value)
3434
3434
    return 1;
3435
 
  return my_decimal_cmp(&value, tmp);
 
3435
  return class_decimal_cmp(&value, tmp);
3436
3436
}
3437
3437
 
3438
3438
 
3439
3439
int cmp_item_decimal::compare(cmp_item *arg)
3440
3440
{
3441
3441
  cmp_item_decimal *l_cmp= (cmp_item_decimal*) arg;
3442
 
  return my_decimal_cmp(&value, &l_cmp->value);
 
3442
  return class_decimal_cmp(&value, &l_cmp->value);
3443
3443
}
3444
3444
 
3445
3445