← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/my_decimal.h

Removed/replaced DBUG symbols and TRUE/FALSE

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/my_decimal.h
 
1
/* Copyright (C) 2005-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/**
 
17
  @file
 
18
 
 
19
  It is interface module to fixed precision decimals library.
 
20
 
 
21
  Most functions use 'uint mask' as parameter, if during operation error
 
22
  which fit in this mask is detected then it will be processed automatically
 
23
  here. (errors are E_DEC_* constants, see include/decimal.h)
 
24
 
 
25
  Most function are just inline wrappers around library calls
 
26
*/
 
27
 
 
28
#ifndef my_decimal_h
 
29
#define my_decimal_h
 
30
 
 
31
C_MODE_START
 
32
#include <decimal.h>
 
33
C_MODE_END
 
34
 
 
35
#define DECIMAL_LONGLONG_DIGITS 22
 
36
#define DECIMAL_LONG_DIGITS 10
 
37
#define DECIMAL_LONG3_DIGITS 8
 
38
 
 
39
/** maximum length of buffer in our big digits (uint32). */
 
40
#define DECIMAL_BUFF_LENGTH 9
 
41
 
 
42
/* the number of digits that my_decimal can possibly contain */
 
43
#define DECIMAL_MAX_POSSIBLE_PRECISION (DECIMAL_BUFF_LENGTH * 9)
 
44
 
 
45
 
 
46
/**
 
47
  maximum guaranteed precision of number in decimal digits (number of our
 
48
  digits * number of decimal digits in one our big digit - number of decimal
 
49
  digits in one our big digit decreased by 1 (because we always put decimal
 
50
  point on the border of our big digits))
 
51
*/
 
52
#define DECIMAL_MAX_PRECISION (DECIMAL_MAX_POSSIBLE_PRECISION - 8*2)
 
53
#define DECIMAL_MAX_SCALE 30
 
54
#define DECIMAL_NOT_SPECIFIED 31
 
55
 
 
56
/**
 
57
  maximum length of string representation (number of maximum decimal
 
58
  digits + 1 position for sign + 1 position for decimal point)
 
59
*/
 
60
#define DECIMAL_MAX_STR_LENGTH (DECIMAL_MAX_POSSIBLE_PRECISION + 2)
 
61
 
 
62
/**
 
63
  maximum size of packet length.
 
64
*/
 
65
#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
 
66
 
 
67
 
 
68
inline uint my_decimal_size(uint precision, uint scale)
 
69
{
 
70
  /*
 
71
    Always allocate more space to allow library to put decimal point
 
72
    where it want
 
73
  */
 
74
  return decimal_size(precision, scale) + 1;
 
75
}
 
76
 
 
77
 
 
78
inline int my_decimal_int_part(uint precision, uint decimals)
 
79
{
 
80
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
 
81
}
 
82
 
 
83
 
 
84
/**
 
85
  my_decimal class limits 'decimal_t' type to what we need in MySQL.
 
86
 
 
87
  It contains internally all necessary space needed by the instance so
 
88
  no extra memory is needed. One should call fix_buffer_pointer() function
 
89
  when he moves my_decimal objects in memory.
 
90
*/
 
91
 
 
92
class my_decimal :public decimal_t
 
93
{
 
94
  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
 
95
 
 
96
public:
 
97
 
 
98
  void init()
 
99
  {
 
100
    len= DECIMAL_BUFF_LENGTH;
 
101
    buf= buffer;
 
102
#if !defined (HAVE_purify) 
 
103
    /* Set buffer to 'random' value to find wrong buffer usage */
 
104
    for (uint i= 0; i < DECIMAL_BUFF_LENGTH; i++)
 
105
      buffer[i]= i;
 
106
#endif
 
107
  }
 
108
  my_decimal()
 
109
  {
 
110
    init();
 
111
  }
 
112
  void fix_buffer_pointer() { buf= buffer; }
 
113
 
 
114
  bool sign() const { return decimal_t::sign; }
 
115
  void sign(bool s) { decimal_t::sign= s; }
 
116
  uint precision() const { return intg + frac; }
 
117
};
 
118
 
 
119
#ifndef MYSQL_CLIENT
 
120
int decimal_operation_results(int result);
 
121
#else
 
122
inline int decimal_operation_results(int result)
 
123
{
 
124
  return result;
 
125
}
 
126
#endif /*MYSQL_CLIENT*/
 
127
 
 
128
inline
 
129
void max_my_decimal(my_decimal *to, int precision, int frac)
 
130
{
 
131
  assert((precision <= DECIMAL_MAX_PRECISION)&&
 
132
              (frac <= DECIMAL_MAX_SCALE));
 
133
  max_decimal(precision, frac, (decimal_t*) to);
 
134
}
 
135
 
 
136
inline void max_internal_decimal(my_decimal *to)
 
137
{
 
138
  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
 
139
}
 
140
 
 
141
inline int check_result(uint mask, int result)
 
142
{
 
143
  if (result & mask)
 
144
    decimal_operation_results(result);
 
145
  return result;
 
146
}
 
147
 
 
148
inline int check_result_and_overflow(uint mask, int result, my_decimal *val)
 
149
{
 
150
  if (check_result(mask, result) & E_DEC_OVERFLOW)
 
151
  {
 
152
    bool sign= val->sign();
 
153
    val->fix_buffer_pointer();
 
154
    max_internal_decimal(val);
 
155
    val->sign(sign);
 
156
  }
 
157
  return result;
 
158
}
 
159
 
 
160
inline uint my_decimal_length_to_precision(uint length, uint scale,
 
161
                                           bool unsigned_flag)
 
162
{
 
163
  return (uint) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
 
164
}
 
165
 
 
166
inline uint32 my_decimal_precision_to_length(uint precision, uint8 scale,
 
167
                                             bool unsigned_flag)
 
168
{
 
169
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
 
170
  return (uint32)(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
 
171
}
 
172
 
 
173
inline
 
174
int my_decimal_string_length(const my_decimal *d)
 
175
{
 
176
  return decimal_string_size(d);
 
177
}
 
178
 
 
179
 
 
180
inline
 
181
int my_decimal_max_length(const my_decimal *d)
 
182
{
 
183
  /* -1 because we do not count \0 */
 
184
  return decimal_string_size(d) - 1;
 
185
}
 
186
 
 
187
 
 
188
inline
 
189
int my_decimal_get_binary_size(uint precision, uint scale)
 
190
{
 
191
  return decimal_bin_size((int)precision, (int)scale);
 
192
}
 
193
 
 
194
 
 
195
inline
 
196
void my_decimal2decimal(const my_decimal *from, my_decimal *to)
 
197
{
 
198
  *to= *from;
 
199
  to->fix_buffer_pointer();
 
200
}
 
201
 
 
202
 
 
203
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
 
204
                      int scale);
 
205
 
 
206
 
 
207
inline
 
208
int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d, int prec,
 
209
                      int scale)
 
210
{
 
211
  return check_result(mask, bin2decimal(bin, (decimal_t*) d, prec, scale));
 
212
}
 
213
 
 
214
 
 
215
inline
 
216
int my_decimal_set_zero(my_decimal *d)
 
217
{
 
218
  decimal_make_zero(((decimal_t*) d));
 
219
  return 0;
 
220
}
 
221
 
 
222
 
 
223
inline
 
224
bool my_decimal_is_zero(const my_decimal *decimal_value)
 
225
{
 
226
  return decimal_is_zero((decimal_t*) decimal_value);
 
227
}
 
228
 
 
229
 
 
230
inline
 
231
int my_decimal_round(uint mask, const my_decimal *from, int scale,
 
232
                     bool truncate, my_decimal *to)
 
233
{
 
234
  return check_result(mask, decimal_round((decimal_t*) from, to, scale,
 
235
                                          (truncate ? TRUNCATE : HALF_UP)));
 
236
}
 
237
 
 
238
 
 
239
inline
 
240
int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to)
 
241
{
 
242
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, FLOOR));
 
243
}
 
244
 
 
245
 
 
246
inline
 
247
int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to)
 
248
{
 
249
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, CEILING));
 
250
}
 
251
 
 
252
 
 
253
#ifndef MYSQL_CLIENT
 
254
int my_decimal2string(uint mask, const my_decimal *d, uint fixed_prec,
 
255
                      uint fixed_dec, char filler, String *str);
 
256
#endif
 
257
 
 
258
inline
 
259
int my_decimal2int(uint mask, const my_decimal *d, my_bool unsigned_flag,
 
260
                   longlong *l)
 
261
{
 
262
  my_decimal rounded;
 
263
  /* decimal_round can return only E_DEC_TRUNCATED */
 
264
  decimal_round((decimal_t*)d, &rounded, 0, HALF_UP);
 
265
  return check_result(mask, (unsigned_flag ?
 
266
                             decimal2ulonglong(&rounded, (ulonglong *)l) :
 
267
                             decimal2longlong(&rounded, l)));
 
268
}
 
269
 
 
270
 
 
271
inline
 
272
int my_decimal2double(uint mask __attribute__((__unused__)), 
 
273
                      const my_decimal *d, double *result)
 
274
{
 
275
  /* No need to call check_result as this will always succeed */
 
276
  return decimal2double((decimal_t*) d, result);
 
277
}
 
278
 
 
279
 
 
280
inline
 
281
int str2my_decimal(uint mask, const char *str, my_decimal *d, char **end)
 
282
{
 
283
  return check_result_and_overflow(mask, string2decimal(str,(decimal_t*)d,end),
 
284
                                   d);
 
285
}
 
286
 
 
287
 
 
288
int str2my_decimal(uint mask, const char *from, uint length,
 
289
                   CHARSET_INFO *charset, my_decimal *decimal_value);
 
290
 
 
291
#if defined(MYSQL_SERVER)
 
292
inline
 
293
int string2my_decimal(uint mask, const String *str, my_decimal *d)
 
294
{
 
295
  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
 
296
}
 
297
 
 
298
 
 
299
my_decimal *date2my_decimal(MYSQL_TIME *ltime, my_decimal *dec);
 
300
 
 
301
 
 
302
#endif /*defined(MYSQL_SERVER) */
 
303
 
 
304
inline
 
305
int double2my_decimal(uint mask, double val, my_decimal *d)
 
306
{
 
307
  return check_result_and_overflow(mask, double2decimal(val, (decimal_t*)d), d);
 
308
}
 
309
 
 
310
 
 
311
inline
 
312
int int2my_decimal(uint mask, longlong i, my_bool unsigned_flag, my_decimal *d)
 
313
{
 
314
  return check_result(mask, (unsigned_flag ?
 
315
                             ulonglong2decimal((ulonglong)i, d) :
 
316
                             longlong2decimal(i, d)));
 
317
}
 
318
 
 
319
 
 
320
inline
 
321
void my_decimal_neg(decimal_t *arg)
 
322
{
 
323
  if (decimal_is_zero(arg))
 
324
  {
 
325
    arg->sign= 0;
 
326
    return;
 
327
  }
 
328
  decimal_neg(arg);
 
329
}
 
330
 
 
331
 
 
332
inline
 
333
int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a,
 
334
                   const my_decimal *b)
 
335
{
 
336
  return check_result_and_overflow(mask,
 
337
                                   decimal_add((decimal_t*)a,(decimal_t*)b,res),
 
338
                                   res);
 
339
}
 
340
 
 
341
 
 
342
inline
 
343
int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a,
 
344
                   const my_decimal *b)
 
345
{
 
346
  return check_result_and_overflow(mask,
 
347
                                   decimal_sub((decimal_t*)a,(decimal_t*)b,res),
 
348
                                   res);
 
349
}
 
350
 
 
351
 
 
352
inline
 
353
int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a,
 
354
                   const my_decimal *b)
 
355
{
 
356
  return check_result_and_overflow(mask,
 
357
                                   decimal_mul((decimal_t*)a,(decimal_t*)b,res),
 
358
                                   res);
 
359
}
 
360
 
 
361
 
 
362
inline
 
363
int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a,
 
364
                   const my_decimal *b, int div_scale_inc)
 
365
{
 
366
  return check_result_and_overflow(mask,
 
367
                                   decimal_div((decimal_t*)a,(decimal_t*)b,res,
 
368
                                               div_scale_inc),
 
369
                                   res);
 
370
}
 
371
 
 
372
 
 
373
inline
 
374
int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a,
 
375
                   const my_decimal *b)
 
376
{
 
377
  return check_result_and_overflow(mask,
 
378
                                   decimal_mod((decimal_t*)a,(decimal_t*)b,res),
 
379
                                   res);
 
380
}
 
381
 
 
382
 
 
383
/**
 
384
  @return
 
385
    -1 if a<b, 1 if a>b and 0 if a==b
 
386
*/
 
387
inline
 
388
int my_decimal_cmp(const my_decimal *a, const my_decimal *b)
 
389
{
 
390
  return decimal_cmp((decimal_t*) a, (decimal_t*) b);
 
391
}
 
392
 
 
393
 
 
394
inline
 
395
int my_decimal_intg(const my_decimal *a)
 
396
{
 
397
  return decimal_intg((decimal_t*) a);
 
398
}
 
399
 
 
400
 
 
401
void my_decimal_trim(ulong *precision, uint *scale);
 
402
 
 
403
 
 
404
#endif /*my_decimal_h*/
 
405