Merge lp:~dedzone/drizzle/ded-decimal into lp:~drizzle-trunk/drizzle/development

[Djellel E. Difallah]

Have just merged decimal and my_decimal, and updated the references then tested it.

[Monty Taylor (mordred)]

Wonderful. Looks like you left in a commentted out section of code:

 +//#include "drizzled/error.h"
 +//#include "drizzled/field.h"

Could you remove those? Otherwise, looks fantastic.

review: Needs Fixing

[Monty Taylor (mordred)]

Awesome. Looks great!

review: Approve

=== modified file 'drizzled/cached_item.h'
--- drizzled/cached_item.h	2010-02-04 08:14:46 +0000
+++ drizzled/cached_item.h	2010-03-28 01:34:23 +0000
@@ -22,7 +22,7 @@
 
 #include "drizzled/memory/sql_alloc.h"
 #include "drizzled/sql_string.h"
-#include "drizzled/my_decimal.h"
+#include "drizzled/decimal.h"
 
 namespace drizzled
 {

=== modified file 'drizzled/decimal.cc'
--- drizzled/decimal.cc	2010-02-04 08:14:46 +0000
+++ drizzled/decimal.cc	2010-03-28 01:34:23 +0000
@@ -112,11 +112,233 @@
 #endif
 
 #include <algorithm>
+#include <time.h>
+#include "drizzled/current_session.h"
+#include "drizzled/error.h"
+#include "drizzled/field.h"
+#include "drizzled/internal/my_sys.h"
 
 using namespace std;
 
 namespace drizzled
 {
+/**
+  report result of decimal operation.
+
+  @param result  decimal library return code (E_DEC_* see include/decimal.h)
+
+  @todo
+    Fix error messages
+
+  @return
+    result
+*/
+
+int decimal_operation_results(int result)
+{
+  switch (result) {
+  case E_DEC_OK:
+    break;
+  case E_DEC_TRUNCATED:
+    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
+			ER_WARN_DATA_TRUNCATED, ER(ER_WARN_DATA_TRUNCATED),
+			"", (long)-1);
+    break;
+  case E_DEC_OVERFLOW:
+    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+                        ER_TRUNCATED_WRONG_VALUE,
+                        ER(ER_TRUNCATED_WRONG_VALUE),
+			"DECIMAL", "");
+    break;
+  case E_DEC_DIV_ZERO:
+    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+			ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
+    break;
+  case E_DEC_BAD_NUM:
+    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+			ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
+			ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
+			"decimal", "", "", (long)-1);
+    break;
+  case E_DEC_OOM:
+    my_error(ER_OUT_OF_RESOURCES, MYF(0));
+    break;
+  default:
+    assert(0);
+  }
+  return result;
+}
+
+
+/**
+  @brief Converting decimal to string
+
+  @details Convert given my_decimal to String; allocate buffer as needed.
+
+  @param[in]   mask        what problems to warn on (mask of E_DEC_* values)
+  @param[in]   d           the decimal to print
+  @param[in]   fixed_prec  overall number of digits if ZEROFILL, 0 otherwise
+  @param[in]   fixed_dec   number of decimal places (if fixed_prec != 0)
+  @param[in]   filler      what char to pad with (ZEROFILL et al.)
+  @param[out]  *str        where to store the resulting string
+
+  @return error coce
+    @retval E_DEC_OK
+    @retval E_DEC_TRUNCATED
+    @retval E_DEC_OVERFLOW
+    @retval E_DEC_OOM
+*/
+
+int my_decimal2string(uint32_t mask, const my_decimal *d,
+                      uint32_t fixed_prec, uint32_t fixed_dec,
+                      char filler, String *str)
+{
+  /*
+    Calculate the size of the string: For DECIMAL(a,b), fixed_prec==a
+    holds true iff the type is also ZEROFILL, which in turn implies
+    UNSIGNED. Hence the buffer for a ZEROFILLed value is the length
+    the user requested, plus one for a possible decimal point, plus
+    one if the user only wanted decimal places, but we force a leading
+    zero on them. Because the type is implicitly UNSIGNED, we do not
+    need to reserve a character for the sign. For all other cases,
+    fixed_prec will be 0, and my_decimal_string_length() will be called
+    instead to calculate the required size of the buffer.
+  */
+  int length= (fixed_prec
+               ? (fixed_prec + ((fixed_prec == fixed_dec) ? 1 : 0) + 1)
+               : my_decimal_string_length(d));
+  int result;
+  if (str->alloc(length))
+    return check_result(mask, E_DEC_OOM);
+  result= decimal2string((decimal_t*) d, (char*) str->ptr(),
+                         &length, (int)fixed_prec, fixed_dec,
+                         filler);
+  str->length(length);
+  return check_result(mask, result);
+}
+
+
+/*
+  Convert from decimal to binary representation
+
+  SYNOPSIS
+    my_decimal2binary()
+    mask        error processing mask
+    d           number for conversion
+    bin         pointer to buffer where to write result
+    prec        overall number of decimal digits
+    scale       number of decimal digits after decimal point
+
+  NOTE
+    Before conversion we round number if it need but produce truncation
+    error in this case
+
+  RETURN
+    E_DEC_OK
+    E_DEC_TRUNCATED
+    E_DEC_OVERFLOW
+*/
+
+int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
+		      int scale)
+{
+  int err1= E_DEC_OK, err2;
+  my_decimal rounded;
+  my_decimal2decimal(d, &rounded);
+  rounded.frac= decimal_actual_fraction(&rounded);
+  if (scale < rounded.frac)
+  {
+    err1= E_DEC_TRUNCATED;
+    /* decimal_round can return only E_DEC_TRUNCATED */
+    decimal_round(&rounded, &rounded, scale, HALF_UP);
+  }
+  err2= decimal2bin(&rounded, bin, prec, scale);
+  if (!err2)
+    err2= err1;
+  return check_result(mask, err2);
+}
+
+
+/*
+  Convert string for decimal when string can be in some multibyte charset
+
+  SYNOPSIS
+    str2my_decimal()
+    mask            error processing mask
+    from            string to process
+    length          length of given string
+    charset         charset of given string
+    decimal_value   buffer for result storing
+
+  RESULT
+    E_DEC_OK
+    E_DEC_TRUNCATED
+    E_DEC_OVERFLOW
+    E_DEC_BAD_NUM
+    E_DEC_OOM
+*/
+
+int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
+                   const CHARSET_INFO * charset, my_decimal *decimal_value)
+{
+  char *end, *from_end;
+  int err;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+  if (charset->mbminlen > 1)
+  {
+    uint32_t dummy_errors;
+    tmp.copy(from, length, charset, &my_charset_utf8_general_ci, &dummy_errors);
+    from= tmp.ptr();
+    length=  tmp.length();
+    charset= &my_charset_bin;
+  }
+  from_end= end= (char*) from+length;
+  err= string2decimal((char *)from, (decimal_t*) decimal_value, &end);
+  if (end != from_end && !err)
+  {
+    /* Give warning if there is something other than end space */
+    for ( ; end < from_end; end++)
+    {
+      if (!my_isspace(&my_charset_utf8_general_ci, *end))
+      {
+        err= E_DEC_TRUNCATED;
+        break;
+      }
+    }
+  }
+  check_result_and_overflow(mask, err, decimal_value);
+  return err;
+}
+
+
+my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec)
+{
+  int64_t date;
+  date = (ltime->year*100L + ltime->month)*100L + ltime->day;
+  if (ltime->time_type > DRIZZLE_TIMESTAMP_DATE)
+    date= ((date*100L + ltime->hour)*100L+ ltime->minute)*100L + ltime->second;
+  if (int2my_decimal(E_DEC_FATAL_ERROR, date, false, dec))
+    return dec;
+  if (ltime->second_part)
+  {
+    dec->buf[(dec->intg-1) / 9 + 1]= ltime->second_part * 1000;
+    dec->frac= 6;
+  }
+  return dec;
+}
+
+
+void my_decimal_trim(uint32_t *precision, uint32_t *scale)
+{
+  if (!(*precision) && !(*scale))
+  {
+    *precision= 10;
+    *scale= 0;
+    return;
+  }
+}
+
 
 /*
   Internally decimal numbers are stored base 10^9 (see DIG_BASE below)
@@ -236,6 +458,7 @@
   } while (0)
 
 
+
 /*
   Get maximum value for given precision and scale
 

=== modified file 'drizzled/decimal.h'
--- drizzled/decimal.h	2010-03-01 01:20:07 +0000
+++ drizzled/decimal.h	2010-03-28 01:34:23 +0000
@@ -15,7 +15,10 @@
 
 #ifndef DRIZZLED_DECIMAL_H
 #define DRIZZLED_DECIMAL_H
-
+#include <assert.h>
+#include <drizzled/sql_string.h>
+#include "drizzled/definitions.h"
+#include "drizzled/my_time.h"
 namespace drizzled
 {
 
@@ -101,6 +104,353 @@
 
 #define E_DEC_ERROR            31
 #define E_DEC_FATAL_ERROR      30
+#define DECIMAL_LONGLONG_DIGITS 22
+#define DECIMAL_LONG_DIGITS 10
+#define DECIMAL_LONG3_DIGITS 8
+
+/** maximum length of buffer in our big digits (uint32_t). */
+#define DECIMAL_BUFF_LENGTH 9
+
+/* the number of digits that my_decimal can possibly contain */
+#define DECIMAL_MAX_POSSIBLE_PRECISION (DECIMAL_BUFF_LENGTH * 9)
+
+
+/**
+  maximum guaranteed precision of number in decimal digits (number of our
+  digits * number of decimal digits in one our big digit - number of decimal
+  digits in one our big digit decreased by 1 (because we always put decimal
+  point on the border of our big digits))
+*/
+#define DECIMAL_MAX_PRECISION (DECIMAL_MAX_POSSIBLE_PRECISION - 8*2)
+#define DECIMAL_MAX_SCALE 30
+#define DECIMAL_NOT_SPECIFIED 31
+
+/**
+  maximum length of string representation (number of maximum decimal
+  digits + 1 position for sign + 1 position for decimal point)
+*/
+#define DECIMAL_MAX_STR_LENGTH (DECIMAL_MAX_POSSIBLE_PRECISION + 2)
+
+/**
+  maximum size of packet length.
+*/
+#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
+
+inline int my_decimal_int_part(uint32_t precision, uint32_t decimals)
+{
+  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
+}
+
+
+/**
+  my_decimal class limits 'decimal_t' type to what we need in MySQL.
+
+  It contains internally all necessary space needed by the instance so
+  no extra memory is needed. One should call fix_buffer_pointer() function
+  when he moves my_decimal objects in memory.
+*/
+
+class my_decimal :public decimal_t
+{
+  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
+
+public:
+
+  void init()
+  {
+    len= DECIMAL_BUFF_LENGTH;
+    buf= buffer;
+	#if !defined (HAVE_purify)
+		/* Set buffer to 'random' value to find wrong buffer usage */
+		for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
+		  buffer[i]= i;
+	#endif
+  }
+  my_decimal()
+  {
+    init();
+  }
+  void fix_buffer_pointer() { buf= buffer; }
+  bool sign() const { return decimal_t::sign; }
+  void sign(bool s) { decimal_t::sign= s; }
+  uint32_t precision() const { return intg + frac; }
+};
+
+int decimal_operation_results(int result);
+
+inline void max_my_decimal(my_decimal *to, int precision, int frac)
+{
+  assert((precision <= DECIMAL_MAX_PRECISION)&&
+              (frac <= DECIMAL_MAX_SCALE));
+  max_decimal(precision, frac, (decimal_t*) to);
+}
+
+inline void max_internal_decimal(my_decimal *to)
+{
+  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
+}
+
+inline int check_result(uint32_t mask, int result)
+{
+  if (result & mask)
+    decimal_operation_results(result);
+  return result;
+}
+
+inline int check_result_and_overflow(uint32_t mask, int result, my_decimal *val)
+{
+  if (check_result(mask, result) & E_DEC_OVERFLOW)
+  {
+    bool sign= val->sign();
+    val->fix_buffer_pointer();
+    max_internal_decimal(val);
+    val->sign(sign);
+  }
+  return result;
+}
+
+inline uint32_t my_decimal_length_to_precision(uint32_t length, uint32_t scale,
+                                           bool unsigned_flag)
+{
+  return (uint32_t) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
+}
+
+inline uint32_t my_decimal_precision_to_length(uint32_t precision, uint8_t scale,
+                                             bool unsigned_flag)
+{
+  set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
+  return static_cast<uint32_t>(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
+}
+
+inline
+int my_decimal_string_length(const my_decimal *d)
+{
+  return decimal_string_size(d);
+}
+
+
+inline
+int my_decimal_max_length(const my_decimal *d)
+{
+  /* -1 because we do not count \0 */
+  return decimal_string_size(d) - 1;
+}
+
+
+inline
+int my_decimal_get_binary_size(uint32_t precision, uint32_t scale)
+{
+  return decimal_bin_size(static_cast<int>(precision), static_cast<int>(scale));
+}
+
+
+inline
+void my_decimal2decimal(const my_decimal *from, my_decimal *to)
+{
+  *to= *from;
+  to->fix_buffer_pointer();
+}
+
+
+int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
+		      int scale);
+
+
+inline
+int binary2my_decimal(uint32_t mask, const unsigned char *bin, my_decimal *d, int prec,
+		      int scale)
+{
+  return check_result(mask, bin2decimal(bin, static_cast<decimal_t*>(d), prec, scale));
+}
+
+
+inline
+int my_decimal_set_zero(my_decimal *d)
+{
+  decimal_make_zero(static_cast<decimal_t*> (d));
+  return 0;
+}
+
+
+inline
+bool my_decimal_is_zero(const my_decimal *decimal_value)
+{
+  return decimal_is_zero(static_cast<const decimal_t*>(decimal_value));
+}
+
+
+inline
+int my_decimal_round(uint32_t mask, const my_decimal *from, int scale,
+                     bool truncate, my_decimal *to)
+{
+  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, scale,
+                                          (truncate ? TRUNCATE : HALF_UP)));
+}
+
+
+inline
+int my_decimal_floor(uint32_t mask, const my_decimal *from, my_decimal *to)
+{
+  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, FLOOR));
+}
+
+
+inline
+int my_decimal_ceiling(uint32_t mask, const my_decimal *from, my_decimal *to)
+{
+  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, CEILING));
+}
+
+
+int my_decimal2string(uint32_t mask, const my_decimal *d, uint32_t fixed_prec,
+                      uint32_t fixed_dec, char filler, String *str);
+
+inline
+int my_decimal2int(uint32_t mask, const my_decimal *d, bool unsigned_flag,
+                   int64_t *l)
+{
+  my_decimal rounded;
+  /* decimal_round can return only E_DEC_TRUNCATED */
+  decimal_round(static_cast<const decimal_t*>(d), &rounded, 0, HALF_UP);
+  return check_result(mask, (unsigned_flag ?
+			     decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
+			     decimal2int64_t(&rounded, l)));
+}
+
+
+inline
+int my_decimal2double(uint32_t, const my_decimal *d, double *result)
+{
+  /* No need to call check_result as this will always succeed */
+  return decimal2double(static_cast<const decimal_t*>(d), result);
+}
+
+
+inline
+int str2my_decimal(uint32_t mask, char *str, my_decimal *d, char **end)
+{
+  return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(d),end),
+                                   d);
+}
+
+
+int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
+                   const CHARSET_INFO * charset, my_decimal *decimal_value);
+
+inline
+int string2my_decimal(uint32_t mask, const String *str, my_decimal *d)
+{
+  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
+}
+
+
+my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec);
+
+
+inline
+int double2my_decimal(uint32_t mask, double val, my_decimal *d)
+{
+  return check_result_and_overflow(mask, double2decimal(val, static_cast<decimal_t*>(d)), d);
+}
+
+
+inline
+int int2my_decimal(uint32_t mask, int64_t i, bool unsigned_flag, my_decimal *d)
+{
+  return check_result(mask, (unsigned_flag ?
+			     uint64_t2decimal(static_cast<uint64_t>(i), d) :
+			     int64_t2decimal(i, d)));
+}
+
+
+inline
+void my_decimal_neg(decimal_t *arg)
+{
+  if (decimal_is_zero(arg))
+  {
+    arg->sign= 0;
+    return;
+  }
+  decimal_neg(arg);
+}
+
+
+inline
+int my_decimal_add(uint32_t mask, my_decimal *res, const my_decimal *a,
+		   const my_decimal *b)
+{
+  return check_result_and_overflow(mask,
+                                   decimal_add(static_cast<const decimal_t*>(a),
+                                               static_cast<const decimal_t*>(b), res),
+                                   res);
+}
+
+
+inline
+int my_decimal_sub(uint32_t mask, my_decimal *res, const my_decimal *a,
+		   const my_decimal *b)
+{
+  return check_result_and_overflow(mask,
+                                   decimal_sub(static_cast<const decimal_t*>(a),
+                                               static_cast<const decimal_t*>(b), res),
+                                   res);
+}
+
+
+inline
+int my_decimal_mul(uint32_t mask, my_decimal *res, const my_decimal *a,
+		   const my_decimal *b)
+{
+  return check_result_and_overflow(mask,
+                                   decimal_mul(static_cast<const decimal_t*>(a),
+                                               static_cast<const decimal_t*>(b),res),
+                                   res);
+}
+
+
+inline
+int my_decimal_div(uint32_t mask, my_decimal *res, const my_decimal *a,
+		   const my_decimal *b, int div_scale_inc)
+{
+  return check_result_and_overflow(mask,
+                                   decimal_div(static_cast<const decimal_t*>(a),
+                                               static_cast<const decimal_t*>(b),res,
+                                               div_scale_inc),
+                                   res);
+}
+
+
+inline
+int my_decimal_mod(uint32_t mask, my_decimal *res, const my_decimal *a,
+		   const my_decimal *b)
+{
+  return check_result_and_overflow(mask,
+                                   decimal_mod(static_cast<const decimal_t*>(a),
+                                               static_cast<const decimal_t*>(b),res),
+                                   res);
+}
+
+
+/**
+  @return
+    -1 if a<b, 1 if a>b and 0 if a==b
+*/
+inline
+int my_decimal_cmp(const my_decimal *a, const my_decimal *b)
+{
+  return decimal_cmp(static_cast<const decimal_t*>(a),
+                     static_cast<const decimal_t*>(b));
+}
+
+
+inline
+int my_decimal_intg(const my_decimal *a)
+{
+  return decimal_intg(static_cast<const decimal_t*>(a));
+}
+
+
+void my_decimal_trim(uint32_t *precision, uint32_t *scale);
 
 } /* namespace drizzled */
 

=== modified file 'drizzled/field.h'
--- drizzled/field.h	2010-03-02 06:41:59 +0000
+++ drizzled/field.h	2010-03-28 01:34:23 +0000
@@ -26,7 +26,7 @@
 #define DRIZZLED_FIELD_H
 
 #include "drizzled/sql_error.h"
-#include "drizzled/my_decimal.h"
+#include "drizzled/decimal.h"
 #include "drizzled/key_map.h"
 #include "drizzled/sql_bitmap.h"
 #include "drizzled/sql_list.h"

=== modified file 'drizzled/hybrid_type.h'
--- drizzled/hybrid_type.h	2010-02-04 08:14:46 +0000
+++ drizzled/hybrid_type.h	2010-03-28 01:34:23 +0000
@@ -20,7 +20,7 @@
 #ifndef DRIZZLED_HYBRID_TYPE_H
 #define DRIZZLED_HYBRID_TYPE_H
 
-#include <drizzled/my_decimal.h>
+#include <drizzled/decimal.h>
 
 namespace drizzled
 {

=== modified file 'drizzled/include.am'
--- drizzled/include.am	2010-03-22 17:38:58 +0000
+++ drizzled/include.am	2010-03-28 01:34:23 +0000
@@ -255,7 +255,6 @@
 			      drizzled/memory/sql_alloc.h \
 			      drizzled/memory/multi_malloc.h \
 			      drizzled/memory/root.h \
-			      drizzled/my_decimal.h \
 			      drizzled/my_getopt.h \
 			      drizzled/my_hash.h \
 			      drizzled/my_time.h \
@@ -632,7 +631,6 @@
 			   drizzled/key_map.cc \
 			   drizzled/lock.cc \
 			   drizzled/lookup_symbol.cc \
-			   drizzled/my_decimal.cc \
 			   drizzled/my_getsystime.cc \
 			   drizzled/my_hash.cc \
 			   drizzled/my_time.cc \

=== modified file 'drizzled/item.h'
--- drizzled/item.h	2010-03-02 06:41:59 +0000
+++ drizzled/item.h	2010-03-28 01:34:23 +0000
@@ -22,7 +22,7 @@
 
 #include <drizzled/dtcollation.h>
 #include <drizzled/my_time.h>
-#include <drizzled/my_decimal.h>
+#include <drizzled/decimal.h>
 #include <drizzled/sql_bitmap.h>
 #include <drizzled/sql_list.h>
 #include "drizzled/memory/sql_alloc.h"

=== removed file 'drizzled/my_decimal.cc'
--- drizzled/my_decimal.cc	2010-02-04 08:14:46 +0000
+++ drizzled/my_decimal.cc	1970-01-01 00:00:00 +0000
@@ -1,243 +0,0 @@
-/* Copyright (C) 2005-2006 MySQL AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; version 2 of the License.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-#include "config.h"
-#include <time.h>
-#include "drizzled/current_session.h"
-#include "drizzled/error.h"
-#include "drizzled/field.h"
-#include "drizzled/internal/my_sys.h"
-
-namespace drizzled
-{
-
-/**
-  report result of decimal operation.
-
-  @param result  decimal library return code (E_DEC_* see include/decimal.h)
-
-  @todo
-    Fix error messages
-
-  @return
-    result
-*/
-
-int decimal_operation_results(int result)
-{
-  switch (result) {
-  case E_DEC_OK:
-    break;
-  case E_DEC_TRUNCATED:
-    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
-			ER_WARN_DATA_TRUNCATED, ER(ER_WARN_DATA_TRUNCATED),
-			"", (long)-1);
-    break;
-  case E_DEC_OVERFLOW:
-    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
-                        ER_TRUNCATED_WRONG_VALUE,
-                        ER(ER_TRUNCATED_WRONG_VALUE),
-			"DECIMAL", "");
-    break;
-  case E_DEC_DIV_ZERO:
-    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
-			ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
-    break;
-  case E_DEC_BAD_NUM:
-    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
-			ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
-			ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
-			"decimal", "", "", (long)-1);
-    break;
-  case E_DEC_OOM:
-    my_error(ER_OUT_OF_RESOURCES, MYF(0));
-    break;
-  default:
-    assert(0);
-  }
-  return result;
-}
-
-
-/**
-  @brief Converting decimal to string
-
-  @details Convert given my_decimal to String; allocate buffer as needed.
-
-  @param[in]   mask        what problems to warn on (mask of E_DEC_* values)
-  @param[in]   d           the decimal to print
-  @param[in]   fixed_prec  overall number of digits if ZEROFILL, 0 otherwise
-  @param[in]   fixed_dec   number of decimal places (if fixed_prec != 0)
-  @param[in]   filler      what char to pad with (ZEROFILL et al.)
-  @param[out]  *str        where to store the resulting string
-
-  @return error coce
-    @retval E_DEC_OK
-    @retval E_DEC_TRUNCATED
-    @retval E_DEC_OVERFLOW
-    @retval E_DEC_OOM
-*/
-
-int my_decimal2string(uint32_t mask, const my_decimal *d,
-                      uint32_t fixed_prec, uint32_t fixed_dec,
-                      char filler, String *str)
-{
-  /*
-    Calculate the size of the string: For DECIMAL(a,b), fixed_prec==a
-    holds true iff the type is also ZEROFILL, which in turn implies
-    UNSIGNED. Hence the buffer for a ZEROFILLed value is the length
-    the user requested, plus one for a possible decimal point, plus
-    one if the user only wanted decimal places, but we force a leading
-    zero on them. Because the type is implicitly UNSIGNED, we do not
-    need to reserve a character for the sign. For all other cases,
-    fixed_prec will be 0, and my_decimal_string_length() will be called
-    instead to calculate the required size of the buffer.
-  */
-  int length= (fixed_prec
-               ? (fixed_prec + ((fixed_prec == fixed_dec) ? 1 : 0) + 1)
-               : my_decimal_string_length(d));
-  int result;
-  if (str->alloc(length))
-    return check_result(mask, E_DEC_OOM);
-  result= decimal2string((decimal_t*) d, (char*) str->ptr(),
-                         &length, (int)fixed_prec, fixed_dec,
-                         filler);
-  str->length(length);
-  return check_result(mask, result);
-}
-
-
-/*
-  Convert from decimal to binary representation
-
-  SYNOPSIS
-    my_decimal2binary()
-    mask        error processing mask
-    d           number for conversion
-    bin         pointer to buffer where to write result
-    prec        overall number of decimal digits
-    scale       number of decimal digits after decimal point
-
-  NOTE
-    Before conversion we round number if it need but produce truncation
-    error in this case
-
-  RETURN
-    E_DEC_OK
-    E_DEC_TRUNCATED
-    E_DEC_OVERFLOW
-*/
-
-int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
-		      int scale)
-{
-  int err1= E_DEC_OK, err2;
-  my_decimal rounded;
-  my_decimal2decimal(d, &rounded);
-  rounded.frac= decimal_actual_fraction(&rounded);
-  if (scale < rounded.frac)
-  {
-    err1= E_DEC_TRUNCATED;
-    /* decimal_round can return only E_DEC_TRUNCATED */
-    decimal_round(&rounded, &rounded, scale, HALF_UP);
-  }
-  err2= decimal2bin(&rounded, bin, prec, scale);
-  if (!err2)
-    err2= err1;
-  return check_result(mask, err2);
-}
-
-
-/*
-  Convert string for decimal when string can be in some multibyte charset
-
-  SYNOPSIS
-    str2my_decimal()
-    mask            error processing mask
-    from            string to process
-    length          length of given string
-    charset         charset of given string
-    decimal_value   buffer for result storing
-
-  RESULT
-    E_DEC_OK
-    E_DEC_TRUNCATED
-    E_DEC_OVERFLOW
-    E_DEC_BAD_NUM
-    E_DEC_OOM
-*/
-
-int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
-                   const CHARSET_INFO * charset, my_decimal *decimal_value)
-{
-  char *end, *from_end;
-  int err;
-  char buff[STRING_BUFFER_USUAL_SIZE];
-  String tmp(buff, sizeof(buff), &my_charset_bin);
-  if (charset->mbminlen > 1)
-  {
-    uint32_t dummy_errors;
-    tmp.copy(from, length, charset, &my_charset_utf8_general_ci, &dummy_errors);
-    from= tmp.ptr();
-    length=  tmp.length();
-    charset= &my_charset_bin;
-  }
-  from_end= end= (char*) from+length;
-  err= string2decimal((char *)from, (decimal_t*) decimal_value, &end);
-  if (end != from_end && !err)
-  {
-    /* Give warning if there is something other than end space */
-    for ( ; end < from_end; end++)
-    {
-      if (!my_isspace(&my_charset_utf8_general_ci, *end))
-      {
-        err= E_DEC_TRUNCATED;
-        break;
-      }
-    }
-  }
-  check_result_and_overflow(mask, err, decimal_value);
-  return err;
-}
-
-
-my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec)
-{
-  int64_t date;
-  date = (ltime->year*100L + ltime->month)*100L + ltime->day;
-  if (ltime->time_type > DRIZZLE_TIMESTAMP_DATE)
-    date= ((date*100L + ltime->hour)*100L+ ltime->minute)*100L + ltime->second;
-  if (int2my_decimal(E_DEC_FATAL_ERROR, date, false, dec))
-    return dec;
-  if (ltime->second_part)
-  {
-    dec->buf[(dec->intg-1) / 9 + 1]= ltime->second_part * 1000;
-    dec->frac= 6;
-  }
-  return dec;
-}
-
-
-void my_decimal_trim(uint32_t *precision, uint32_t *scale)
-{
-  if (!(*precision) && !(*scale))
-  {
-    *precision= 10;
-    *scale= 0;
-    return;
-  }
-}
-
-} /* namespace drizzled */

=== removed file 'drizzled/my_decimal.h'
--- drizzled/my_decimal.h	2010-02-04 08:14:46 +0000
+++ drizzled/my_decimal.h	1970-01-01 00:00:00 +0000
@@ -1,395 +0,0 @@
-/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2008 Sun Microsystems
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-/**
-  @file
-
-  It is interface module to fixed precision decimals library.
-
-  Most functions use 'uint32_t mask' as parameter, if during operation error
-  which fit in this mask is detected then it will be processed automatically
-  here. (errors are E_DEC_* constants, see drizzled/decimal.h)
-
-  Most function are just inline wrappers around library calls
-*/
-
-#ifndef DRIZZLED_MY_DECIMAL_H
-#define DRIZZLED_MY_DECIMAL_H
-
-#include <drizzled/decimal.h>
-#include <drizzled/my_time.h>
-#include <drizzled/definitions.h>
-#include <drizzled/sql_string.h>
-
-namespace drizzled
-{
-
-#define DECIMAL_LONGLONG_DIGITS 22
-#define DECIMAL_LONG_DIGITS 10
-#define DECIMAL_LONG3_DIGITS 8
-
-/** maximum length of buffer in our big digits (uint32_t). */
-#define DECIMAL_BUFF_LENGTH 9
-
-/* the number of digits that my_decimal can possibly contain */
-#define DECIMAL_MAX_POSSIBLE_PRECISION (DECIMAL_BUFF_LENGTH * 9)
-
-
-/**
-  maximum guaranteed precision of number in decimal digits (number of our
-  digits * number of decimal digits in one our big digit - number of decimal
-  digits in one our big digit decreased by 1 (because we always put decimal
-  point on the border of our big digits))
-*/
-#define DECIMAL_MAX_PRECISION (DECIMAL_MAX_POSSIBLE_PRECISION - 8*2)
-#define DECIMAL_MAX_SCALE 30
-#define DECIMAL_NOT_SPECIFIED 31
-
-/**
-  maximum length of string representation (number of maximum decimal
-  digits + 1 position for sign + 1 position for decimal point)
-*/
-#define DECIMAL_MAX_STR_LENGTH (DECIMAL_MAX_POSSIBLE_PRECISION + 2)
-
-/**
-  maximum size of packet length.
-*/
-#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
-
-inline int my_decimal_int_part(uint32_t precision, uint32_t decimals)
-{
-  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
-}
-
-
-/**
-  my_decimal class limits 'decimal_t' type to what we need in MySQL.
-
-  It contains internally all necessary space needed by the instance so
-  no extra memory is needed. One should call fix_buffer_pointer() function
-  when he moves my_decimal objects in memory.
-*/
-
-class my_decimal :public decimal_t
-{
-  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
-
-public:
-
-  void init()
-  {
-    len= DECIMAL_BUFF_LENGTH;
-    buf= buffer;
-#if !defined (HAVE_purify)
-    /* Set buffer to 'random' value to find wrong buffer usage */
-    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
-      buffer[i]= i;
-#endif
-  }
-  my_decimal()
-  {
-    init();
-  }
-  void fix_buffer_pointer() { buf= buffer; }
-
-  bool sign() const { return decimal_t::sign; }
-  void sign(bool s) { decimal_t::sign= s; }
-  uint32_t precision() const { return intg + frac; }
-};
-
-int decimal_operation_results(int result);
-
-inline
-void max_my_decimal(my_decimal *to, int precision, int frac)
-{
-  assert((precision <= DECIMAL_MAX_PRECISION)&&
-              (frac <= DECIMAL_MAX_SCALE));
-  max_decimal(precision, frac, (decimal_t*) to);
-}
-
-inline void max_internal_decimal(my_decimal *to)
-{
-  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
-}
-
-inline int check_result(uint32_t mask, int result)
-{
-  if (result & mask)
-    decimal_operation_results(result);
-  return result;
-}
-
-inline int check_result_and_overflow(uint32_t mask, int result, my_decimal *val)
-{
-  if (check_result(mask, result) & E_DEC_OVERFLOW)
-  {
-    bool sign= val->sign();
-    val->fix_buffer_pointer();
-    max_internal_decimal(val);
-    val->sign(sign);
-  }
-  return result;
-}
-
-inline uint32_t my_decimal_length_to_precision(uint32_t length, uint32_t scale,
-                                           bool unsigned_flag)
-{
-  return (uint32_t) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
-}
-
-inline uint32_t my_decimal_precision_to_length(uint32_t precision, uint8_t scale,
-                                             bool unsigned_flag)
-{
-  set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
-  return static_cast<uint32_t>(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
-}
-
-inline
-int my_decimal_string_length(const my_decimal *d)
-{
-  return decimal_string_size(d);
-}
-
-
-inline
-int my_decimal_max_length(const my_decimal *d)
-{
-  /* -1 because we do not count \0 */
-  return decimal_string_size(d) - 1;
-}
-
-
-inline
-int my_decimal_get_binary_size(uint32_t precision, uint32_t scale)
-{
-  return decimal_bin_size(static_cast<int>(precision), static_cast<int>(scale));
-}
-
-
-inline
-void my_decimal2decimal(const my_decimal *from, my_decimal *to)
-{
-  *to= *from;
-  to->fix_buffer_pointer();
-}
-
-
-int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
-		      int scale);
-
-
-inline
-int binary2my_decimal(uint32_t mask, const unsigned char *bin, my_decimal *d, int prec,
-		      int scale)
-{
-  return check_result(mask, bin2decimal(bin, static_cast<decimal_t*>(d), prec, scale));
-}
-
-
-inline
-int my_decimal_set_zero(my_decimal *d)
-{
-  decimal_make_zero(static_cast<decimal_t*> (d));
-  return 0;
-}
-
-
-inline
-bool my_decimal_is_zero(const my_decimal *decimal_value)
-{
-  return decimal_is_zero(static_cast<const decimal_t*>(decimal_value));
-}
-
-
-inline
-int my_decimal_round(uint32_t mask, const my_decimal *from, int scale,
-                     bool truncate, my_decimal *to)
-{
-  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, scale,
-                                          (truncate ? TRUNCATE : HALF_UP)));
-}
-
-
-inline
-int my_decimal_floor(uint32_t mask, const my_decimal *from, my_decimal *to)
-{
-  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, FLOOR));
-}
-
-
-inline
-int my_decimal_ceiling(uint32_t mask, const my_decimal *from, my_decimal *to)
-{
-  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, CEILING));
-}
-
-
-int my_decimal2string(uint32_t mask, const my_decimal *d, uint32_t fixed_prec,
-                      uint32_t fixed_dec, char filler, String *str);
-
-inline
-int my_decimal2int(uint32_t mask, const my_decimal *d, bool unsigned_flag,
-                   int64_t *l)
-{
-  my_decimal rounded;
-  /* decimal_round can return only E_DEC_TRUNCATED */
-  decimal_round(static_cast<const decimal_t*>(d), &rounded, 0, HALF_UP);
-  return check_result(mask, (unsigned_flag ?
-			     decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
-			     decimal2int64_t(&rounded, l)));
-}
-
-
-inline
-int my_decimal2double(uint32_t, const my_decimal *d, double *result)
-{
-  /* No need to call check_result as this will always succeed */
-  return decimal2double(static_cast<const decimal_t*>(d), result);
-}
-
-
-inline
-int str2my_decimal(uint32_t mask, char *str, my_decimal *d, char **end)
-{
-  return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(d),end),
-                                   d);
-}
-
-
-int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
-                   const CHARSET_INFO * charset, my_decimal *decimal_value);
-
-inline
-int string2my_decimal(uint32_t mask, const String *str, my_decimal *d)
-{
-  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
-}
-
-
-my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec);
-
-
-inline
-int double2my_decimal(uint32_t mask, double val, my_decimal *d)
-{
-  return check_result_and_overflow(mask, double2decimal(val, static_cast<decimal_t*>(d)), d);
-}
-
-
-inline
-int int2my_decimal(uint32_t mask, int64_t i, bool unsigned_flag, my_decimal *d)
-{
-  return check_result(mask, (unsigned_flag ?
-			     uint64_t2decimal(static_cast<uint64_t>(i), d) :
-			     int64_t2decimal(i, d)));
-}
-
-
-inline
-void my_decimal_neg(decimal_t *arg)
-{
-  if (decimal_is_zero(arg))
-  {
-    arg->sign= 0;
-    return;
-  }
-  decimal_neg(arg);
-}
-
-
-inline
-int my_decimal_add(uint32_t mask, my_decimal *res, const my_decimal *a,
-		   const my_decimal *b)
-{
-  return check_result_and_overflow(mask,
-                                   decimal_add(static_cast<const decimal_t*>(a),
-                                               static_cast<const decimal_t*>(b), res),
-                                   res);
-}
-
-
-inline
-int my_decimal_sub(uint32_t mask, my_decimal *res, const my_decimal *a,
-		   const my_decimal *b)
-{
-  return check_result_and_overflow(mask,
-                                   decimal_sub(static_cast<const decimal_t*>(a),
-                                               static_cast<const decimal_t*>(b), res),
-                                   res);
-}
-
-
-inline
-int my_decimal_mul(uint32_t mask, my_decimal *res, const my_decimal *a,
-		   const my_decimal *b)
-{
-  return check_result_and_overflow(mask,
-                                   decimal_mul(static_cast<const decimal_t*>(a),
-                                               static_cast<const decimal_t*>(b),res),
-                                   res);
-}
-
-
-inline
-int my_decimal_div(uint32_t mask, my_decimal *res, const my_decimal *a,
-		   const my_decimal *b, int div_scale_inc)
-{
-  return check_result_and_overflow(mask,
-                                   decimal_div(static_cast<const decimal_t*>(a),
-                                               static_cast<const decimal_t*>(b),res,
-                                               div_scale_inc),
-                                   res);
-}
-
-
-inline
-int my_decimal_mod(uint32_t mask, my_decimal *res, const my_decimal *a,
-		   const my_decimal *b)
-{
-  return check_result_and_overflow(mask,
-                                   decimal_mod(static_cast<const decimal_t*>(a),
-                                               static_cast<const decimal_t*>(b),res),
-                                   res);
-}
-
-
-/**
-  @return
-    -1 if a<b, 1 if a>b and 0 if a==b
-*/
-inline
-int my_decimal_cmp(const my_decimal *a, const my_decimal *b)
-{
-  return decimal_cmp(static_cast<const decimal_t*>(a),
-                     static_cast<const decimal_t*>(b));
-}
-
-
-inline
-int my_decimal_intg(const my_decimal *a)
-{
-  return decimal_intg(static_cast<const decimal_t*>(a));
-}
-
-
-void my_decimal_trim(uint32_t *precision, uint32_t *scale);
-
-} /* namespace drizzled */
-
-#endif /* DRIZZLED_MY_DECIMAL_H */

=== modified file 'drizzled/temporal.cc'
--- drizzled/temporal.cc	2010-02-04 08:14:46 +0000
+++ drizzled/temporal.cc	2010-03-28 01:34:23 +0000
@@ -37,7 +37,7 @@
 #include "config.h"
 
 #include "drizzled/charset_info.h"
-#include "drizzled/my_decimal.h"
+#include "drizzled/decimal.h"
 #include "drizzled/calendar.h"
 #include "drizzled/temporal.h"
 #ifdef NOTYETIMPLEMENTED

=== modified file 'support-files/drizzle.spec.in'
--- support-files/drizzle.spec.in	2010-02-12 20:53:27 +0000
+++ support-files/drizzle.spec.in	2010-03-28 01:34:23 +0000
@@ -312,7 +312,6 @@
 %{_includedir}/drizzled/message/statement_transform.h
 %{_includedir}/drizzled/message/table.pb.h
 %{_includedir}/drizzled/message/transaction.pb.h
-%{_includedir}/drizzled/my_decimal.h
 %{_includedir}/drizzled/my_error.h
 %{_includedir}/drizzled/my_getopt.h
 %{_includedir}/drizzled/my_hash.h