← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/sum.cc

  • Committer: Brian Aker
  • Date: 2010-12-25 00:44:06 UTC
  • mto: This revision was merged to the branch mainline in revision 2031.
  • Revision ID: brian@tangent.org-20101225004406-4xna6p795yqkaony
Second pass through function names.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/sum.cc
643
643
    sum_int= item->sum_int;
644
644
    break;
645
645
  case DECIMAL_RESULT:
646
 
    my_decimal2decimal(&item->sum_dec, &sum_dec);
 
646
    class_decimal2decimal(&item->sum_dec, &sum_dec);
647
647
    break;
648
648
  case REAL_RESULT:
649
649
    sum= item->sum;
765
765
  /* TODO: check if the following assignments are really needed */
766
766
  if (hybrid_type == DECIMAL_RESULT)
767
767
  {
768
 
    my_decimal2decimal(item->dec_buffs, dec_buffs);
769
 
    my_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
 
768
    class_decimal2decimal(item->dec_buffs, dec_buffs);
 
769
    class_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
770
770
  }
771
771
  else
772
772
    sum= item->sum;
849
849
  if (hybrid_type == DECIMAL_RESULT)
850
850
  {
851
851
    int64_t result;
852
 
    my_decimal2int(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, unsigned_flag,
 
852
    class_decimal2int(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, unsigned_flag,
853
853
                   &result);
854
854
    return result;
855
855
  }
861
861
{
862
862
  assert(fixed == 1);
863
863
  if (hybrid_type == DECIMAL_RESULT)
864
 
    my_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
 
864
    class_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
865
865
  return sum;
866
866
}
867
867
 
937
937
 
938
938
  virtual void div(Hybrid_type *val, uint64_t u) const
939
939
  {
940
 
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
 
940
    int2_class_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
941
941
    val->used_dec_buf_no= 0;
942
942
    val->traits= Hybrid_type_traits_decimal::instance();
943
943
    val->traits->div(val, u);
1330
1330
    return val_decimal_from_real(val);
1331
1331
 
1332
1332
  sum_dec= dec_buffs + curr_dec_buff;
1333
 
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
 
1333
  int2_class_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
1334
1334
  class_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
1335
1335
  return val;
1336
1336
}
1632
1632
  case INT_RESULT:
1633
1633
    return (double) sum_int;
1634
1634
  case DECIMAL_RESULT:
1635
 
    my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
 
1635
    class_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
1636
1636
    return sum;
1637
1637
  case REAL_RESULT:
1638
1638
    return sum;
1656
1656
  case DECIMAL_RESULT:
1657
1657
  {
1658
1658
    int64_t result;
1659
 
    my_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
 
1659
    class_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
1660
1660
    return sum_int;
1661
1661
  }
1662
1662
  default:
1673
1673
 
1674
1674
  switch (hybrid_type) {
1675
1675
  case STRING_RESULT:
1676
 
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
 
1676
    string2_class_decimal(E_DEC_FATAL_ERROR, &value, val);
1677
1677
    break;
1678
1678
  case REAL_RESULT:
1679
 
    double2my_decimal(E_DEC_FATAL_ERROR, sum, val);
 
1679
    double2_class_decimal(E_DEC_FATAL_ERROR, sum, val);
1680
1680
    break;
1681
1681
  case DECIMAL_RESULT:
1682
1682
    val= &sum_dec;
1683
1683
    break;
1684
1684
  case INT_RESULT:
1685
 
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
 
1685
    int2_class_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
1686
1686
    break;
1687
1687
  case ROW_RESULT:
1688
1688
    // This case should never be choosen
1708
1708
    str->set_real(sum,decimals, &my_charset_bin);
1709
1709
    break;
1710
1710
  case DECIMAL_RESULT:
1711
 
    my_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
 
1711
    class_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
1712
1712
    return str;
1713
1713
  case INT_RESULT:
1714
1714
    str->set_int(sum_int, unsigned_flag, &my_charset_bin);
1785
1785
      if (!args[0]->null_value &&
1786
1786
          (null_value || (class_decimal_cmp(&sum_dec, val) > 0)))
1787
1787
      {
1788
 
        my_decimal2decimal(val, &sum_dec);
 
1788
        class_decimal2decimal(val, &sum_dec);
1789
1789
        null_value= 0;
1790
1790
      }
1791
1791
    }
1848
1848
      if (!args[0]->null_value &&
1849
1849
          (null_value || (class_decimal_cmp(val, &sum_dec) > 0)))
1850
1850
      {
1851
 
        my_decimal2decimal(val, &sum_dec);
 
1851
        class_decimal2decimal(val, &sum_dec);
1852
1852
        null_value= 0;
1853
1853
      }
1854
1854
    }
2080
2080
    }
2081
2081
    else
2082
2082
      tmp= 1;
2083
 
    my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec, res, f_precision, f_scale);
 
2083
    class_decimal2binary(E_DEC_FATAL_ERROR, arg_dec, res, f_precision, f_scale);
2084
2084
    res+= dec_bin_size;
2085
2085
    int8store(res, tmp);
2086
2086
  }
2179
2179
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2180
2180
    if (!args[0]->null_value)
2181
2181
    {
2182
 
      binary2my_decimal(E_DEC_FATAL_ERROR, res,
 
2182
      binary2_class_decimal(E_DEC_FATAL_ERROR, res,
2183
2183
                        dec_buffs + 1, f_precision, f_scale);
2184
2184
      field_count= sint8korr(res + dec_bin_size);
2185
2185
      class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, dec_buffs + 1);
2186
 
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_buffs,
 
2186
      class_decimal2binary(E_DEC_FATAL_ERROR, dec_buffs,
2187
2187
                        res, f_precision, f_scale);
2188
2188
      res+= dec_bin_size;
2189
2189
      field_count++;
2379
2379
    return 0;
2380
2380
 
2381
2381
  my_decimal dec_count, dec_field;
2382
 
  binary2my_decimal(E_DEC_FATAL_ERROR,
 
2382
  binary2_class_decimal(E_DEC_FATAL_ERROR,
2383
2383
                    field->ptr, &dec_field, f_precision, f_scale);
2384
 
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
 
2384
  int2_class_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
2385
2385
  class_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
2386
2386
                 &dec_field, &dec_count, prec_increment);
2387
2387
  return dec_buf;
2427
2427
  dec= Item_variance_field::val_decimal(dec_buf);
2428
2428
  if (!dec)
2429
2429
    return 0;
2430
 
  my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
 
2430
  class_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
2431
2431
  assert(nr >= 0.0);
2432
2432
  nr= sqrt(nr);
2433
 
  double2my_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
 
2433
  double2_class_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
2434
2434
  class_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, false, dec_buf);
2435
2435
  return dec_buf;
2436
2436
}