my_decimal.cc 7.79 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2005-2006 MySQL AB
unknown's avatar
unknown committed
2 3 4

   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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6 7 8 9 10 11 12 13 14

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

unknown's avatar
unknown committed
16
#include "mysql_priv.h"
17 18
#include <time.h>

unknown's avatar
unknown committed
19 20

#ifndef MYSQL_CLIENT
unknown's avatar
unknown committed
21 22
/**
  report result of decimal operation.
unknown's avatar
unknown committed
23

unknown's avatar
unknown committed
24
  @param result  decimal library return code (E_DEC_* see include/decimal.h)
unknown's avatar
unknown committed
25

unknown's avatar
unknown committed
26
  @todo
27 28
    Fix error messages

unknown's avatar
unknown committed
29
  @return
unknown's avatar
unknown committed
30 31
    result
*/
32

unknown's avatar
unknown committed
33 34
int decimal_operation_results(int result)
{
35
  switch (result) {
unknown's avatar
unknown committed
36 37 38 39 40 41 42 43 44
  case E_DEC_OK:
    break;
  case E_DEC_TRUNCATED:
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			WARN_DATA_TRUNCATED, ER(WARN_DATA_TRUNCATED),
			"", (long)-1);
    break;
  case E_DEC_OVERFLOW:
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
45 46 47
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE),
			"DECIMAL", "");
unknown's avatar
unknown committed
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    break;
  case E_DEC_DIV_ZERO:
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
			ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
    break;
  case E_DEC_BAD_NUM:
    push_warning_printf(current_thd, MYSQL_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:
    DBUG_ASSERT(0);
  }
  return result;
}


69 70
/**
  @brief Converting decimal to string
unknown's avatar
unknown committed
71

72 73 74 75 76 77 78 79
  @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
unknown's avatar
unknown committed
80

81 82 83 84 85
  @return error coce
    @retval E_DEC_OK
    @retval E_DEC_TRUNCATED
    @retval E_DEC_OVERFLOW
    @retval E_DEC_OOM
unknown's avatar
unknown committed
86 87 88
*/

int my_decimal2string(uint mask, const my_decimal *d,
unknown's avatar
unknown committed
89
                      uint fixed_prec, uint fixed_dec,
90
                      char filler, String *str)
unknown's avatar
unknown committed
91
{
92 93 94 95 96 97 98 99 100 101 102 103 104 105
  /*
    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));
unknown's avatar
unknown committed
106 107
  int result;
  if (str->alloc(length))
108
    return check_result(mask, E_DEC_OOM);
109
  result= decimal2string((decimal_t*) d, (char*) str->ptr(),
unknown's avatar
unknown committed
110
                         &length, (int)fixed_prec, fixed_dec,
111
                         filler);
unknown's avatar
unknown committed
112
  str->length(length);
113
  return check_result(mask, result);
unknown's avatar
unknown committed
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
}


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

138
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
unknown's avatar
unknown committed
139 140 141 142 143
		      int scale)
{
  int err1= E_DEC_OK, err2;
  my_decimal rounded;
  my_decimal2decimal(d, &rounded);
unknown's avatar
unknown committed
144
  rounded.frac= decimal_actual_fraction(&rounded);
unknown's avatar
unknown committed
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
  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
*/
176

unknown's avatar
unknown committed
177 178 179
int str2my_decimal(uint mask, const char *from, uint length,
                   CHARSET_INFO *charset, my_decimal *decimal_value)
{
180
  char *end, *from_end;
unknown's avatar
unknown committed
181 182 183 184 185 186 187 188 189 190 191
  int err;
  char buff[STRING_BUFFER_USUAL_SIZE];
  String tmp(buff, sizeof(buff), &my_charset_bin);
  if (charset->mbminlen > 1)
  {
    uint dummy_errors;
    tmp.copy(from, length, charset, &my_charset_latin1, &dummy_errors);
    from= tmp.ptr();
    length=  tmp.length();
    charset= &my_charset_bin;
  }
192
  from_end= end= (char*) from+length;
193
  err= string2decimal((char *)from, (decimal_t*) decimal_value, &end);
194 195
  if (end != from_end && !err)
  {
196
    /* Give warning if there is something other than end space */
197 198 199 200 201 202 203 204 205
    for ( ; end < from_end; end++)
    {
      if (!my_isspace(&my_charset_latin1, *end))
      {
        err= E_DEC_TRUNCATED;
        break;
      }
    }
  }
206
  check_result_and_overflow(mask, err, decimal_value);
unknown's avatar
unknown committed
207 208 209 210
  return err;
}


211
my_decimal *date2my_decimal(MYSQL_TIME *ltime, my_decimal *dec)
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
{
  longlong date;
  date = (ltime->year*100L + ltime->month)*100L + ltime->day;
  if (ltime->time_type > MYSQL_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;
}


unknown's avatar
unknown committed
228 229 230 231 232 233 234 235 236 237 238
void my_decimal_trim(ulong *precision, uint *scale)
{
  if (!(*precision) && !(*scale))
  {
    *precision= 10;
    *scale= 0;
    return;
  }
}


unknown's avatar
unknown committed
239 240 241
#ifndef DBUG_OFF
/* routines for debugging print */

242 243 244
#define DIG_PER_DEC1 9
#define ROUND_UP(X)  (((X)+DIG_PER_DEC1-1)/DIG_PER_DEC1)

unknown's avatar
unknown committed
245 246 247 248
/* print decimal */
void
print_decimal(const my_decimal *dec)
{
249 250 251 252 253 254 255 256 257 258
  int i, end;
  char buff[512], *pos;
  pos= buff;
  pos+= my_sprintf(buff, (buff, "Decimal: sign: %d  intg: %d  frac: %d  { ",
                          dec->sign(), dec->intg, dec->frac));
  end= ROUND_UP(dec->frac)+ROUND_UP(dec->intg)-1;
  for (i=0; i < end; i++)
    pos+= my_sprintf(pos, (pos, "%09d, ", dec->buf[i]));
  pos+= my_sprintf(pos, (pos, "%09d }\n", dec->buf[i]));
  fputs(buff, DBUG_FILE);
unknown's avatar
unknown committed
259 260 261 262 263
}


/* print decimal with its binary representation */
void
264
print_decimal_buff(const my_decimal *dec, const uchar* ptr, int length)
unknown's avatar
unknown committed
265 266 267
{
  print_decimal(dec);
  fprintf(DBUG_FILE, "Record: ");
268
  for (int i= 0; i < length; i++)
unknown's avatar
unknown committed
269 270 271 272 273
  {
    fprintf(DBUG_FILE, "%02X ", (uint)((uchar *)ptr)[i]);
  }
  fprintf(DBUG_FILE, "\n");
}
274 275


unknown's avatar
unknown committed
276
const char *dbug_decimal_as_string(char *buff, const my_decimal *val)
277
{
unknown's avatar
unknown committed
278
  int length= DECIMAL_MAX_STR_LENGTH;
279
  if (!val)
unknown's avatar
unknown committed
280 281 282
    return "NULL";
  (void)decimal2string((decimal_t*) val, buff, &length, 0,0,0);
  return buff;
283 284
}

unknown's avatar
unknown committed
285
#endif /*DBUG_OFF*/
unknown's avatar
unknown committed
286 287 288


#endif /*MYSQL_CLIENT*/