my_decimal.cc 7.83 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 21 22 23 24 25 26 27

#ifndef MYSQL_CLIENT
/*
  report result of decimal operation

  SYNOPSIS
    decimal_operation_results()
    result  decimal library return code (E_DEC_* see include/decimal.h)

28 29 30 31
  TODO
    Fix error messages

  RETURN
unknown's avatar
unknown committed
32 33
    result
*/
34

unknown's avatar
unknown committed
35 36
int decimal_operation_results(int result)
{
37
  switch (result) {
unknown's avatar
unknown committed
38 39 40 41 42 43 44 45 46
  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,
47 48 49
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE),
			"DECIMAL", "");
unknown's avatar
unknown committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
    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;
}


71 72
/**
  @brief Converting decimal to string
unknown's avatar
unknown committed
73

74 75 76 77 78 79 80 81
  @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
82

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

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


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

140
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
unknown's avatar
unknown committed
141 142 143 144 145
		      int scale)
{
  int err1= E_DEC_OK, err2;
  my_decimal rounded;
  my_decimal2decimal(d, &rounded);
unknown's avatar
unknown committed
146
  rounded.frac= decimal_actual_fraction(&rounded);
unknown's avatar
unknown committed
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 176 177
  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
*/
178

unknown's avatar
unknown committed
179 180 181
int str2my_decimal(uint mask, const char *from, uint length,
                   CHARSET_INFO *charset, my_decimal *decimal_value)
{
182
  char *end, *from_end;
unknown's avatar
unknown committed
183 184 185 186 187 188 189 190 191 192 193
  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;
  }
194
  from_end= end= (char*) from+length;
195
  err= string2decimal((char *)from, (decimal_t*) decimal_value, &end);
196 197
  if (end != from_end && !err)
  {
198
    /* Give warning if there is something other than end space */
199 200 201 202 203 204 205 206 207
    for ( ; end < from_end; end++)
    {
      if (!my_isspace(&my_charset_latin1, *end))
      {
        err= E_DEC_TRUNCATED;
        break;
      }
    }
  }
208
  check_result_and_overflow(mask, err, decimal_value);
unknown's avatar
unknown committed
209 210 211 212
  return err;
}


213
my_decimal *date2my_decimal(MYSQL_TIME *ltime, my_decimal *dec)
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
{
  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
230 231 232 233 234 235 236 237 238 239 240
void my_decimal_trim(ulong *precision, uint *scale)
{
  if (!(*precision) && !(*scale))
  {
    *precision= 10;
    *scale= 0;
    return;
  }
}


unknown's avatar
unknown committed
241 242 243
#ifndef DBUG_OFF
/* routines for debugging print */

244 245 246
#define DIG_PER_DEC1 9
#define ROUND_UP(X)  (((X)+DIG_PER_DEC1-1)/DIG_PER_DEC1)

unknown's avatar
unknown committed
247 248 249 250
/* print decimal */
void
print_decimal(const my_decimal *dec)
{
251 252 253 254 255 256 257 258 259 260
  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
261 262 263 264 265
}


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


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

unknown's avatar
unknown committed
287
#endif /*DBUG_OFF*/
unknown's avatar
unknown committed
288 289 290


#endif /*MYSQL_CLIENT*/