← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/my_decimal.h

  • Committer: Brian Aker
  • Date: 2008-07-16 01:30:24 UTC
  • Revision ID: brian@tangent.org-20080716013024-nmnogwdpa459jrch
First pass of cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/my_decimal.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
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 */
19
15
 
20
16
/**
21
17
  @file
22
18
 
23
19
  It is interface module to fixed precision decimals library.
24
20
 
25
 
  Most functions use 'uint32_t mask' as parameter, if during operation error
 
21
  Most functions use 'uint mask' as parameter, if during operation error
26
22
  which fit in this mask is detected then it will be processed automatically
27
23
  here. (errors are E_DEC_* constants, see include/decimal.h)
28
24
 
32
28
#ifndef my_decimal_h
33
29
#define my_decimal_h
34
30
 
35
 
#ifdef __cplusplus
36
 
extern "C" {
37
 
#endif
38
 
 
39
 
#include <mystrings/decimal.h>
40
 
 
41
 
#ifdef __cplusplus
42
 
}
43
 
#endif
44
 
 
 
31
C_MODE_START
 
32
#include <decimal.h>
 
33
C_MODE_END
45
34
 
46
35
#define DECIMAL_LONGLONG_DIGITS 22
47
36
#define DECIMAL_LONG_DIGITS 10
48
37
#define DECIMAL_LONG3_DIGITS 8
49
38
 
50
 
/** maximum length of buffer in our big digits (uint32_t). */
 
39
/** maximum length of buffer in our big digits (uint32). */
51
40
#define DECIMAL_BUFF_LENGTH 9
52
41
 
53
42
/* the number of digits that my_decimal can possibly contain */
76
65
#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
77
66
 
78
67
 
79
 
inline uint32_t my_decimal_size(uint32_t precision, uint32_t scale)
 
68
inline uint my_decimal_size(uint precision, uint scale)
80
69
{
81
70
  /*
82
71
    Always allocate more space to allow library to put decimal point
86
75
}
87
76
 
88
77
 
89
 
inline int my_decimal_int_part(uint32_t precision, uint32_t decimals)
 
78
inline int my_decimal_int_part(uint precision, uint decimals)
90
79
{
91
80
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
92
81
}
112
101
    buf= buffer;
113
102
#if !defined (HAVE_purify) 
114
103
    /* Set buffer to 'random' value to find wrong buffer usage */
115
 
    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
 
104
    for (uint i= 0; i < DECIMAL_BUFF_LENGTH; i++)
116
105
      buffer[i]= i;
117
106
#endif
118
107
  }
124
113
 
125
114
  bool sign() const { return decimal_t::sign; }
126
115
  void sign(bool s) { decimal_t::sign= s; }
127
 
  uint32_t precision() const { return intg + frac; }
 
116
  uint precision() const { return intg + frac; }
128
117
};
129
118
 
 
119
#ifndef MYSQL_CLIENT
130
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*/
131
127
 
132
128
inline
133
129
void max_my_decimal(my_decimal *to, int precision, int frac)
142
138
  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
143
139
}
144
140
 
145
 
inline int check_result(uint32_t mask, int result)
 
141
inline int check_result(uint mask, int result)
146
142
{
147
143
  if (result & mask)
148
144
    decimal_operation_results(result);
149
145
  return result;
150
146
}
151
147
 
152
 
inline int check_result_and_overflow(uint32_t mask, int result, my_decimal *val)
 
148
inline int check_result_and_overflow(uint mask, int result, my_decimal *val)
153
149
{
154
150
  if (check_result(mask, result) & E_DEC_OVERFLOW)
155
151
  {
161
157
  return result;
162
158
}
163
159
 
164
 
inline uint32_t my_decimal_length_to_precision(uint32_t length, uint32_t scale,
 
160
inline uint my_decimal_length_to_precision(uint length, uint scale,
165
161
                                           bool unsigned_flag)
166
162
{
167
163
  return (uint) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
168
164
}
169
165
 
170
 
inline uint32_t my_decimal_precision_to_length(uint32_t precision, uint8_t scale,
 
166
inline uint32 my_decimal_precision_to_length(uint precision, uint8 scale,
171
167
                                             bool unsigned_flag)
172
168
{
173
169
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
174
 
  return (uint32_t)(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
 
170
  return (uint32)(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
175
171
}
176
172
 
177
173
inline
190
186
 
191
187
 
192
188
inline
193
 
int my_decimal_get_binary_size(uint32_t precision, uint32_t scale)
 
189
int my_decimal_get_binary_size(uint precision, uint scale)
194
190
{
195
191
  return decimal_bin_size((int)precision, (int)scale);
196
192
}
204
200
}
205
201
 
206
202
 
207
 
int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
 
203
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
208
204
                      int scale);
209
205
 
210
206
 
211
207
inline
212
 
int binary2my_decimal(uint32_t mask, const unsigned char *bin, my_decimal *d, int prec,
 
208
int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d, int prec,
213
209
                      int scale)
214
210
{
215
211
  return check_result(mask, bin2decimal(bin, (decimal_t*) d, prec, scale));
232
228
 
233
229
 
234
230
inline
235
 
int my_decimal_round(uint32_t mask, const my_decimal *from, int scale,
 
231
int my_decimal_round(uint mask, const my_decimal *from, int scale,
236
232
                     bool truncate, my_decimal *to)
237
233
{
238
234
  return check_result(mask, decimal_round((decimal_t*) from, to, scale,
241
237
 
242
238
 
243
239
inline
244
 
int my_decimal_floor(uint32_t mask, const my_decimal *from, my_decimal *to)
 
240
int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to)
245
241
{
246
242
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, FLOOR));
247
243
}
248
244
 
249
245
 
250
246
inline
251
 
int my_decimal_ceiling(uint32_t mask, const my_decimal *from, my_decimal *to)
 
247
int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to)
252
248
{
253
249
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, CEILING));
254
250
}
255
251
 
256
252
 
257
 
int my_decimal2string(uint32_t mask, const my_decimal *d, uint32_t fixed_prec,
258
 
                      uint32_t fixed_dec, char filler, String *str);
 
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
259
257
 
260
258
inline
261
 
int my_decimal2int(uint32_t mask, const my_decimal *d, bool unsigned_flag,
 
259
int my_decimal2int(uint mask, const my_decimal *d, my_bool unsigned_flag,
262
260
                   int64_t *l)
263
261
{
264
262
  my_decimal rounded;
271
269
 
272
270
 
273
271
inline
274
 
int my_decimal2double(uint32_t mask __attribute__((unused)), 
 
272
int my_decimal2double(uint mask __attribute__((__unused__)), 
275
273
                      const my_decimal *d, double *result)
276
274
{
277
275
  /* No need to call check_result as this will always succeed */
280
278
 
281
279
 
282
280
inline
283
 
int str2my_decimal(uint32_t mask, char *str, my_decimal *d, char **end)
 
281
int str2my_decimal(uint mask, const char *str, my_decimal *d, char **end)
284
282
{
285
283
  return check_result_and_overflow(mask, string2decimal(str,(decimal_t*)d,end),
286
284
                                   d);
287
285
}
288
286
 
289
287
 
290
 
int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
291
 
                   const CHARSET_INFO * charset, my_decimal *decimal_value);
 
288
int str2my_decimal(uint mask, const char *from, uint length,
 
289
                   CHARSET_INFO *charset, my_decimal *decimal_value);
292
290
 
293
 
#if defined(DRIZZLE_SERVER)
 
291
#if defined(MYSQL_SERVER)
294
292
inline
295
 
int string2my_decimal(uint32_t mask, const String *str, my_decimal *d)
 
293
int string2my_decimal(uint mask, const String *str, my_decimal *d)
296
294
{
297
295
  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
298
296
}
299
297
 
300
298
 
301
 
my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec);
302
 
 
303
 
 
304
 
#endif /*defined(DRIZZLE_SERVER) */
 
299
my_decimal *date2my_decimal(MYSQL_TIME *ltime, my_decimal *dec);
 
300
 
 
301
 
 
302
#endif /*defined(MYSQL_SERVER) */
305
303
 
306
304
inline
307
 
int double2my_decimal(uint32_t mask, double val, my_decimal *d)
 
305
int double2my_decimal(uint mask, double val, my_decimal *d)
308
306
{
309
307
  return check_result_and_overflow(mask, double2decimal(val, (decimal_t*)d), d);
310
308
}
311
309
 
312
310
 
313
311
inline
314
 
int int2my_decimal(uint32_t mask, int64_t i, bool unsigned_flag, my_decimal *d)
 
312
int int2my_decimal(uint mask, int64_t i, my_bool unsigned_flag, my_decimal *d)
315
313
{
316
314
  return check_result(mask, (unsigned_flag ?
317
315
                             uint64_t2decimal((uint64_t)i, d) :
332
330
 
333
331
 
334
332
inline
335
 
int my_decimal_add(uint32_t mask, my_decimal *res, const my_decimal *a,
 
333
int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a,
336
334
                   const my_decimal *b)
337
335
{
338
336
  return check_result_and_overflow(mask,
342
340
 
343
341
 
344
342
inline
345
 
int my_decimal_sub(uint32_t mask, my_decimal *res, const my_decimal *a,
 
343
int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a,
346
344
                   const my_decimal *b)
347
345
{
348
346
  return check_result_and_overflow(mask,
352
350
 
353
351
 
354
352
inline
355
 
int my_decimal_mul(uint32_t mask, my_decimal *res, const my_decimal *a,
 
353
int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a,
356
354
                   const my_decimal *b)
357
355
{
358
356
  return check_result_and_overflow(mask,
362
360
 
363
361
 
364
362
inline
365
 
int my_decimal_div(uint32_t mask, my_decimal *res, const my_decimal *a,
 
363
int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a,
366
364
                   const my_decimal *b, int div_scale_inc)
367
365
{
368
366
  return check_result_and_overflow(mask,
373
371
 
374
372
 
375
373
inline
376
 
int my_decimal_mod(uint32_t mask, my_decimal *res, const my_decimal *a,
 
374
int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a,
377
375
                   const my_decimal *b)
378
376
{
379
377
  return check_result_and_overflow(mask,
400
398
}
401
399
 
402
400
 
403
 
void my_decimal_trim(uint32_t *precision, uint32_t *scale);
 
401
void my_decimal_trim(ulong *precision, uint *scale);
404
402
 
405
403
 
406
404
#endif /*my_decimal_h*/