~drizzle-trunk/drizzle/development

/* Copyright (C) 2000 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

/** @file

 *

 * @brief  SQL standard-compliant decimal number handling

 *

 * @note

 * This library implements SQL standard "exact numeric" type

 * and is not at all generic, but rather intentinally crippled to

 * follow the standard :) 

 */

/*

=======================================================================

  Quoting the standard

  (SQL:2003, Part 2 Foundations, aka ISO/IEC 9075-2:2003)

4.4.2 Characteristics of numbers, page 27:

  An exact numeric type has a precision P and a scale S. P is a positive

  integer that determines the number of significant digits in a

  particular radix R, where R is either 2 or 10. S is a non-negative

  integer. Every value of an exact numeric type of scale S is of the

  form n*10^{-S}, where n is an integer such that ­-R^P <= n <= R^P.

  [...]

  If an assignment of some number would result in a loss of its most

  significant digit, an exception condition is raised. If least

  significant digits are lost, implementation-defined rounding or

  truncating occurs, with no exception condition being raised.

  [...]

  Whenever an exact or approximate numeric value is assigned to an exact

  numeric value site, an approximation of its value that preserves

  leading significant digits after rounding or truncating is represented

  in the declared type of the target. The value is converted to have the

  precision and scale of the target. The choice of whether to truncate

  or round is implementation-defined.

  [...]

  All numeric values between the smallest and the largest value,

  inclusive, in a given exact numeric type have an approximation

  obtained by rounding or truncation for that type; it is

  implementation-defined which other numeric values have such

  approximations.

5.3 <literal>, page 143

  <exact numeric literal> ::=

    <unsigned integer> [ <period> [ <unsigned integer> ] ]

  | <period> <unsigned integer>

6.1 <data type>, page 165:

  19) The <scale> of an <exact numeric type> shall not be greater than

      the <precision> of the <exact numeric type>.

  20) For the <exact numeric type>s DECIMAL and NUMERIC:

    a) The maximum value of <precision> is implementation-defined.

       <precision> shall not be greater than this value.

    b) The maximum value of <scale> is implementation-defined. <scale>

       shall not be greater than this maximum value.

  21) NUMERIC specifies the data type exact numeric, with the decimal

      precision and scale specified by the <precision> and <scale>.

  22) DECIMAL specifies the data type exact numeric, with the decimal

      scale specified by the <scale> and the implementation-defined

      decimal precision equal to or greater than the value of the

      specified <precision>.

6.26 <numeric value expression>, page 241:

  1) If the declared type of both operands of a dyadic arithmetic

     operator is exact numeric, then the declared type of the result is

     an implementation-defined exact numeric type, with precision and

     scale determined as follows:

   a) Let S1 and S2 be the scale of the first and second operands

      respectively.

   b) The precision of the result of addition and subtraction is

      implementation-defined, and the scale is the maximum of S1 and S2.

   c) The precision of the result of multiplication is

      implementation-defined, and the scale is S1 + S2.

   d) The precision and scale of the result of division are

      implementation-defined.

*/

#include <config.h>

#include <drizzled/definitions.h>

#include <drizzled/internal/m_string.h>

#include <drizzled/charset.h>

#include <drizzled/type/decimal.h>

#include <plugin/myisam/myisampack.h>

#include <drizzled/util/test.h>

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#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:

    my_error(ER_DIVISION_BY_ZERO, MYF(0));

    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 type::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 code

    @retval E_DEC_OK

    @retval E_DEC_TRUNCATED

    @retval E_DEC_OVERFLOW

    @retval E_DEC_OOM

*/

int class_decimal2string(const type::Decimal *d,

                         uint32_t fixed_dec, String *str)

{

  uint32_t mask= E_DEC_FATAL_ERROR;

  /*

    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 class_decimal_string_length() will be called

    instead to calculate the required size of the buffer.

  */

  int length= (int)(0

                    ? (uint32_t)(((0 == fixed_dec) ? 1 : 0) + 1)

                    : (uint32_t)d->string_length());

  int result;

  str->alloc(length);

  result= decimal2string((decimal_t*) d, (char*) str->ptr(),

                         &length, (int)0, fixed_dec,

                         '0');

  str->length(length);

  return check_result(mask, result);

}

/**

  @brief  Convert from decimal to binary representation

  @param[in]   mask        error processing mask

  @param[in]   d           number for conversion

  @param[out]  bin         pointer to buffer where to write result

  @param[in]   prec        overall number of decimal digits

  @param[in]   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 error code

   @retval E_DEC_OK

   @retval E_DEC_TRUNCATED

   @retval E_DEC_OVERFLOW

*/

namespace type {

int Decimal::val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const

{

  int err1= E_DEC_OK, err2;

  type::Decimal rounded;

  class_decimal2decimal(this, &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);

}

} // namespace type

/**

  @brief Convert string for decimal when string can be in some multibyte charset

  @param  mask            error processing mask

  @param  from            string to process

  @param  length          length of given string

  @param  charset         charset of given string

  @return Error code

   @retval E_DEC_OK

   @retval E_DEC_TRUNCATED

   @retval E_DEC_OVERFLOW

   @retval E_DEC_BAD_NUM

   @retval E_DEC_OOM

*/

int type::Decimal::store(uint32_t mask, const char *from, uint32_t length, const charset_info_st * charset)

{

  char *end, *from_end;

  int err;

  char buff[STRING_BUFFER_USUAL_SIZE];

  String tmp(buff, sizeof(buff), &my_charset_bin);

  if (charset->mbminlen > 1)

  {

    tmp.copy(from, length, &my_charset_utf8_general_ci);

    from= tmp.ptr();

    length=  tmp.length();

    charset= &my_charset_bin;

  }

  from_end= end= (char*) from+length;

  err= string2decimal((char *)from, (decimal_t*) this, &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);

  return err;

}

void type::Decimal::convert(double &result) const

{

  decimal2double(static_cast<const decimal_t*>(this), &result);

}

type::Decimal *date2_class_decimal(type::Time *ltime, type::Decimal *dec)

{

  int64_t date;

  date = (ltime->year*100L + ltime->month)*100L + ltime->day;

  if (ltime->time_type > type::DRIZZLE_TIMESTAMP_DATE)

    date= ((date*100L + ltime->hour)*100L+ ltime->minute)*100L + ltime->second;

  if (int2_class_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 class_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)

  So one variable of type decimal_digit_t is limited:

      0 < decimal_digit <= DIG_MAX < DIG_BASE

  in the struct st_decimal_t:

    intg is the number of *decimal* digits (NOT number of decimal_digit_t's !)

         before the point

    frac - number of decimal digits after the point

    buf is an array of decimal_digit_t's

    len is the length of buf (length of allocated space) in decimal_digit_t's,

        not in bytes

*/

typedef decimal_digit_t dec1;

typedef int64_t      dec2;

#define DIG_PER_DEC1 9

#define DIG_MASK     100000000

#define DIG_BASE     1000000000

#define DIG_MAX      (DIG_BASE-1)

template<typename T> 

inline static T round_up(const T &x)

{

  return (x+DIG_PER_DEC1-1)/DIG_PER_DEC1;

}

static const dec1 powers10[DIG_PER_DEC1+1]={

  1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

static const int dig2bytes[DIG_PER_DEC1+1]={0, 1, 1, 2, 2, 3, 3, 4, 4, 4};

static const dec1 frac_max[DIG_PER_DEC1-1]={

  900000000, 990000000, 999000000,

  999900000, 999990000, 999999000,

  999999900, 999999990 };

#ifdef HAVE_VALGRIND

#define sanity(d) assert((d)->len > 0)

#else

#define sanity(d) assert((d)->len >0 && ((d)->buf[0] | \

                              (d)->buf[(d)->len-1] | 1))

#endif

inline static void fix_intg_frac_error(const int len, int &intg1, int &frac1, int &error)

{

  if (unlikely(intg1+frac1 > len))

  {

    if (unlikely(intg1 > len))

    {

      intg1=(len);

      frac1=0;

      error=E_DEC_OVERFLOW;

    }

    else

    {

      frac1=(len)-intg1;

      error=E_DEC_TRUNCATED;

    }

  }

  else

    error=E_DEC_OK;

}

/* assume carry <= 1 */

inline static void add(dec1 &to, const dec1 &from1, const dec1& from2, dec1 &carry)

{

  dec1 a=from1+from2+carry;

  assert(carry <= 1);

  if ((carry= (a >= DIG_BASE))) /* no division here! */

    a-=DIG_BASE;

  to=a;

}

inline static void add2(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)

{

  dec2 a=dec2(from1)+from2+carry;

  if ((carry= (a >= DIG_BASE)))

    a-=DIG_BASE;

  if (unlikely(a >= DIG_BASE))

  {

    a-=DIG_BASE;

    carry++;

  }

  to=dec1(a);

}

/* to=from1-from2 */

inline static void sub(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)

{

  dec1 a=from1-from2-carry;

  if ((carry= (a < 0)))

    a+=DIG_BASE;

  to=a;

}

/* to=from1-from2 */

inline static void sub2(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)

{

  dec1 a=from1-from2-carry;

  if ((carry= (a < 0)))

    a+=DIG_BASE;

  if (unlikely(a < 0))

  {

    a+=DIG_BASE;

    carry++;

  }

  to=a;

}

/**

  @brief  Get maximum value for given precision and scale

  @param  precision/scale  see decimal_bin_size() below

  @param  to              decimal where where the result will be stored

                      to->buf and to->len must be set.

*/

void max_decimal(int precision, int frac, decimal_t *to)

{

  int intpart;

  dec1 *buf= to->buf;

  assert(precision && precision >= frac);

  to->sign= 0;

  if ((intpart= to->intg= (precision - frac)))

  {

    const int firstdigits= intpart % DIG_PER_DEC1;

    if (firstdigits)

      *buf++= powers10[firstdigits] - 1; /* get 9 99 999 ... */

    for(intpart/= DIG_PER_DEC1; intpart; intpart--)

      *buf++= DIG_MAX;

  }

  if ((to->frac= frac))

  {

    const int lastdigits= frac % DIG_PER_DEC1;

    for(frac/= DIG_PER_DEC1; frac; frac--)

      *buf++= DIG_MAX;

    if (lastdigits)

      *buf= frac_max[lastdigits - 1];

  }

}

static dec1 *remove_leading_zeroes(const decimal_t *from, int *intg_result)

{

  int intg= from->intg, i;

  dec1 *buf0= from->buf;

  i= ((intg - 1) % DIG_PER_DEC1) + 1;

  while (intg > 0 && *buf0 == 0)

  {

    intg-= i;

    i= DIG_PER_DEC1;

    buf0++;

  }

  if (intg > 0)

  {

    for (i= (intg - 1) % DIG_PER_DEC1; *buf0 < powers10[i--]; intg--) ;

    assert(intg > 0);

  }

  else

    intg=0;

  *intg_result= intg;

  return buf0;

}

/**

 @brief Count actual length of fraction part (without ending zeroes)

 @param from    number for processing

*/

int decimal_actual_fraction(decimal_t *from)

{

  int frac= from->frac, i;

  dec1 *buf0= from->buf + round_up(from->intg) + round_up(frac) - 1;

  if (frac == 0)

    return 0;

  i= ((frac - 1) % DIG_PER_DEC1 + 1);

  while (frac > 0 && *buf0 == 0)

  {

    frac-= i;

    i= DIG_PER_DEC1;

    buf0--;

  }

  if (frac > 0)

  {

    for (i= DIG_PER_DEC1 - ((frac - 1) % DIG_PER_DEC1); *buf0 % powers10[i++] == 0; frac--) {};

  }

  return frac;

}

/**

 @brief  Convert decimal to its printable string representation

 @param  from       value to convert

 @param  to         points to buffer where string representation

                    should be stored

 @param  to_len     in:  size of to buffer

                    out: length of the actually written string

 @param  fixed_precision 0 if representation can be variable length and

                        fixed_decimals will not be checked in this case.

                        Put number as with fixed point position with this

                        number of digits (sign counted and decimal point is

                        counted)

 @param  fixed_decimals  number digits after point.

 @param  filler          character to fill gaps in case of fixed_precision > 0

 @return error code

   @retval E_DEC_OK

   @retval E_DEC_TRUNCATED

   @retval E_DEC_OVERFLOW

*/

int decimal2string(const decimal_t *from, char *to, int *to_len,

                   int fixed_precision, int fixed_decimals,

                   char filler)

{

  int len, intg, frac= from->frac, i, intg_len, frac_len, fill;

  /* number digits before decimal point */

  int fixed_intg= (fixed_precision ?

                   (fixed_precision - fixed_decimals) : 0);

  int error=E_DEC_OK;

  char *s=to;

  dec1 *buf, *buf0=from->buf, tmp;

  assert(*to_len >= 2+from->sign);

  /* removing leading zeroes */

  buf0= remove_leading_zeroes(from, &intg);

  if (unlikely(intg+frac==0))

  {

    intg=1;

    tmp=0;

    buf0=&tmp;

  }

  if (!(intg_len= fixed_precision ? fixed_intg : intg))

    intg_len= 1;

  frac_len= fixed_precision ? fixed_decimals : frac;

  len= from->sign + intg_len + test(frac) + frac_len;

  if (fixed_precision)

  {

    if (frac > fixed_decimals)

    {

      error= E_DEC_TRUNCATED;

      frac= fixed_decimals;

    }

    if (intg > fixed_intg)

    {

      error= E_DEC_OVERFLOW;

      intg= fixed_intg;

    }

  }

  else if (unlikely(len > --*to_len)) /* reserve one byte for \0 */

  {

    int j= len-*to_len;

    error= (frac && j <= frac + 1) ? E_DEC_TRUNCATED : E_DEC_OVERFLOW;

    if (frac && j >= frac + 1) j--;

    if (j > frac)

    {

      intg-= j-frac;

      frac= 0;

    }

    else

      frac-=j;

    len= from->sign + intg_len + test(frac) + frac_len;

  }

  *to_len=len;

  s[len]=0;

  if (from->sign)

    *s++='-';

  if (frac)

  {

    char *s1= s + intg_len;

    fill= frac_len - frac;

    buf=buf0+round_up(intg);

    *s1++='.';

    for (; frac>0; frac-=DIG_PER_DEC1)

    {

      dec1 x=*buf++;

      for (i=min(frac, DIG_PER_DEC1); i; i--)

      {

        dec1 y=x/DIG_MASK;

        *s1++='0'+(unsigned char)y;

        x-=y*DIG_MASK;

        x*=10;

      }

    }

    for(; fill; fill--)

      *s1++=filler;

  }

  fill= intg_len - intg;

  if (intg == 0)

    fill--; /* symbol 0 before digital point */

  for(; fill; fill--)

    *s++=filler;

  if (intg)

  {

    s+=intg;

    for (buf=buf0+round_up(intg); intg>0; intg-=DIG_PER_DEC1)

    {

      dec1 x=*--buf;

      for (i=min(intg, DIG_PER_DEC1); i; i--)

      {

        dec1 y=x/10;

        *--s='0'+(unsigned char)(x-y*10);

        x=y;

      }

    }

  }

  else

    *s= '0';

  return error;

}

/**

 @brief  Return bounds of decimal digits in the number

 @param  from  decimal number for processing

 @param  start_result  index (from 0 ) of first decimal digits will

                       be written by this address

 @param  end_result   index of position just after last decimal digit

                     be written by this address

*/

static void digits_bounds(decimal_t *from, int *start_result, int *end_result)

{

  int start, stop, i;

  dec1 *buf_beg= from->buf;

  dec1 *end= from->buf + round_up(from->intg) + round_up(from->frac);

  dec1 *buf_end= end - 1;

  /* find non-zero digit from number begining */

  while (buf_beg < end && *buf_beg == 0)

    buf_beg++;

  if (buf_beg >= end)

  {

    /* it is zero */

    *start_result= *end_result= 0;

    return;

  }

  /* find non-zero decimal digit from number begining */

  if (buf_beg == from->buf && from->intg)

  {

    start= DIG_PER_DEC1 - (i= ((from->intg-1) % DIG_PER_DEC1 + 1));

    i--;

  }

  else

  {

    i= DIG_PER_DEC1 - 1;

    start= (int) ((buf_beg - from->buf) * DIG_PER_DEC1);

  }

  if (buf_beg < end)

    for (; *buf_beg < powers10[i--]; start++) ;

  *start_result= start; /* index of first decimal digit (from 0) */

  /* find non-zero digit at the end */

  while (buf_end > buf_beg  && *buf_end == 0)

    buf_end--;

  /* find non-zero decimal digit from the end */

  if (buf_end == end - 1 && from->frac)

  {

    stop= (int) (((buf_end - from->buf) * DIG_PER_DEC1 +

           (i= ((from->frac - 1) % DIG_PER_DEC1 + 1))));

    i= DIG_PER_DEC1 - i + 1;

  }

  else

  {

    stop= (int) ((buf_end - from->buf + 1) * DIG_PER_DEC1);

    i= 1;

  }

  for (; *buf_end % powers10[i++] == 0; stop--) {};

  *end_result= stop; /* index of position after last decimal digit (from 0) */

}

/**

 @param Left shift for alignment of data in buffer

 @param  dec     pointer to decimal number which have to be shifted

 @param  shift   number of decimal digits on which it should be shifted

 @param  beg     beginning of decimal digits (see digits_bounds())

 @param  end     end of decimal digits (see digits_bounds())

 @note

   Result fitting in the buffer should be garanted.

   'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)

 @todo  Above note is unclear - is 'garanted' a typo for 'guaranteed'

 or 'granted'?

*/

static void do_mini_left_shift(decimal_t *dec, int shift, int beg, int last)

{

  dec1 *from= dec->buf + round_up(beg + 1) - 1;