~ubuntu-branches/ubuntu/trusty/drizzle/trusty

/* 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 */

#pragma once
#include <assert.h>
#include <drizzled/sql_string.h>
#include <drizzled/definitions.h>
#include <drizzled/type/time.h>

namespace drizzled {

typedef enum
{
  TRUNCATE= 0,
  HALF_EVEN,
  HALF_UP,
  CEILING,
  FLOOR
} decimal_round_mode;
typedef int32_t decimal_digit_t;

struct decimal_t {
  int    intg, frac, len;
  bool sign;
  decimal_digit_t *buf;

  /* set a decimal_t to zero */
  inline void set_zero()
  {							    
    buf[0]= 0;
    intg= 1;
    frac= 0;
    sign= 0; 
  }

  /* negate a decimal */
  inline void negate()
  {
    sign^=1;
  }

  int isZero() const;

};

int internal_str2dec(char *from, decimal_t *to, char **end,
                     bool fixed);
int decimal2string(const decimal_t *from, char *to, int *to_len,
                   int fixed_precision, int fixed_decimals,
                   char filler);
int decimal2uint64_t(const decimal_t *from, uint64_t *to);
int uint64_t2decimal(const uint64_t from, decimal_t *to);
int decimal2int64_t(const decimal_t *from, int64_t *to);
int int64_t2decimal(const int64_t from, decimal_t *to);
int decimal2double(const decimal_t *from, double *to);
int double2decimal(const double from, decimal_t *to);
int decimal_actual_fraction(decimal_t *from);
int decimal2bin(const decimal_t *from, unsigned char *to, int precision, int scale);
int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale);

int decimal_bin_size(int precision, int scale);

int decimal_intg(const decimal_t *from);
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
                int scale_incr);
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
                  decimal_round_mode mode);
void max_decimal(int precision, int frac, decimal_t *to);

inline int string2decimal(char *from, decimal_t *to, char **end)
{
  return internal_str2dec(from, to, end, false);
}

/*
  returns the length of the buffer to hold string representation
  of the decimal (including decimal dot, possible sign and \0)
*/

inline int decimal_string_size(const decimal_t *dec)
{
  return (dec->intg ? dec->intg : 1) + dec->frac + (dec->frac > 0) + 2;
}

/*
  conventions:

    decimal_smth() == 0     -- everything's ok
    decimal_smth() <= 1     -- result is usable, but precision loss is possible
    decimal_smth() <= 2     -- result can be unusable, most significant digits
                               could've been lost
    decimal_smth() >  2     -- no result was generated
*/

#define E_DEC_OK                0
#define E_DEC_TRUNCATED         1
#define E_DEC_OVERFLOW          2
#define E_DEC_DIV_ZERO          4
#define E_DEC_BAD_NUM           8
#define E_DEC_OOM              16

#define E_DEC_ERROR            31
#define E_DEC_FATAL_ERROR      30


#define DECIMAL_LONGLONG_DIGITS 22

/** maximum length of buffer in our big digits (uint32_t). */
#define DECIMAL_BUFF_LENGTH 9

/* the number of digits that type::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)

inline int class_decimal_int_part(uint32_t precision, uint32_t decimals)
{
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
}

int decimal_operation_results(int result);

inline void max_Decimal(type::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(type::Decimal *to)
{
  max_Decimal(to, DECIMAL_MAX_PRECISION, 0);
}

inline int check_result(uint32_t mask, int result)
{
  if (result & mask)
    decimal_operation_results(result);
  return result;
}

namespace type {
/**
  type 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 type::Decimal objects in memory.
*/

class Decimal : public decimal_t
{
  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];

public:

  void init()
  {
    len= DECIMAL_BUFF_LENGTH;
    buf= buffer;
#if !defined (HAVE_VALGRIND)
    /* Set buffer to 'random' value to find wrong buffer usage */
    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
      buffer[i]= i;
#endif
  }

  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 val_int32(uint32_t mask, bool unsigned_flag, int64_t *l) const
  {
    type::Decimal rounded;
    /* decimal_round can return only E_DEC_TRUNCATED */
    decimal_round(static_cast<const decimal_t*>(this), &rounded, 0, HALF_UP);
    return check_result(mask, (unsigned_flag ?
                               decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
                               decimal2int64_t(&rounded, l)));
  }

  int string_length() const
  {
    return decimal_string_size(this);
  }

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

  int store(uint32_t mask, const char *from, uint32_t length, const charset_info_st * charset);

  int store(uint32_t mask, char *str, char **end)
  {
    return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(this), end));
  }

  int store(uint32_t mask, const String *str)
  {
    return store(mask, str->ptr(), str->length(), str->charset());
  }

  int check_result_and_overflow(uint32_t mask, int result)
  {
    if (check_result(mask, result) & E_DEC_OVERFLOW)
    {
      bool _sign= sign();
      fix_buffer_pointer();
      max_internal_decimal(this);
      sign(_sign);
    }
    return result;
  }

  void convert(double &value) const;
};

} // type

std::ostream& operator<<(std::ostream& output, const type::Decimal &dec);

inline uint32_t class_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 class_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 class_decimal_max_length(const type::Decimal *d)
{
  /* -1 because we do not count \0 */
  return decimal_string_size(d) - 1;
}


inline
int class_decimal_get_binary_size(uint32_t precision, uint32_t scale)
{
  return decimal_bin_size(static_cast<int>(precision), static_cast<int>(scale));
}


inline
void class_decimal2decimal(const type::Decimal *from, type::Decimal *to)
{
  *to= *from;
  to->fix_buffer_pointer();
}


inline
int binary2_class_decimal(uint32_t mask, const unsigned char *bin, type::Decimal *d, int prec,
		      int scale)
{
  return check_result(mask, bin2decimal(bin, static_cast<decimal_t*>(d), prec, scale));
}


inline
int class_decimal_round(uint32_t mask, const type::Decimal *from, int scale,
                     bool truncate, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, scale,
                                          (truncate ? TRUNCATE : HALF_UP)));
}


inline
int class_decimal_floor(uint32_t mask, const type::Decimal *from, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, FLOOR));
}


inline
int class_decimal_ceiling(uint32_t mask, const type::Decimal *from, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, CEILING));
}


int class_decimal2string(const type::Decimal *d,
                         uint32_t fixed_dec, String *str);


inline
int class_decimal2double(uint32_t, const type::Decimal *d, double *result)
{
  /* No need to call check_result as this will always succeed */
  return decimal2double(static_cast<const decimal_t*>(d), result);
}


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


inline
int double2_class_decimal(uint32_t mask, double val, type::Decimal *d)
{
  return d->check_result_and_overflow(mask, double2decimal(val, static_cast<decimal_t*>(d)));
}


inline
int int2_class_decimal(uint32_t mask, int64_t i, bool unsigned_flag, type::Decimal *d)
{
  return check_result(mask, (unsigned_flag ?
			     uint64_t2decimal(static_cast<uint64_t>(i), d) :
			     int64_t2decimal(i, d)));
}


inline
void class_decimal_neg(decimal_t *arg)
{
  if (arg->isZero())
  {
    arg->sign= 0;
    return;
  }
  arg->negate();
}


inline
int class_decimal_add(uint32_t mask, type::Decimal *res, const type::Decimal *a,
		   const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_add(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b), res));
}


inline
int class_decimal_sub(uint32_t mask, type::Decimal *res, const type::Decimal *a,
		   const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_sub(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b), res));
}


inline
int class_decimal_mul(uint32_t mask, type::Decimal *res, const type::Decimal *a,
		   const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_mul(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res));
}


inline
int class_decimal_div(uint32_t mask, type::Decimal *res, const type::Decimal *a,
		   const type::Decimal *b, int div_scale_inc)
{
  return res->check_result_and_overflow(mask,
                                        decimal_div(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res,
                                                    div_scale_inc));
}


inline
int class_decimal_mod(uint32_t mask, type::Decimal *res, const type::Decimal *a,
		   const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_mod(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res));
}


/**
  @return
    -1 if a<b, 1 if a>b and 0 if a==b
*/
inline
int class_decimal_cmp(const type::Decimal *a, const type::Decimal *b)
{
  return decimal_cmp(static_cast<const decimal_t*>(a),
                     static_cast<const decimal_t*>(b));
}


inline
int class_decimal_intg(const type::Decimal *a)
{
  return decimal_intg(static_cast<const decimal_t*>(a));
}


void class_decimal_trim(uint32_t *precision, uint32_t *scale);

inline type::Decimal &decimal_zero_const()
{
  static type::Decimal _decimal_zero;
  return _decimal_zero;
}

double my_double_round(double value, int64_t dec, bool dec_unsigned,
                       bool truncate);


#define decimal_zero decimal_zero_const()

} /* namespace drizzled */