← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/my_decimal.h

  • Committer: Stewart Smith
  • Date: 2009-01-12 05:43:13 UTC
  • mto: (784.1.4 for-brian)
  • mto: This revision was merged to the branch mainline in revision 785.
  • Revision ID: stewart@flamingspork.com-20090112054313-edk6kpf4l6kpz4j7
fix archive_basic for drizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/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 */
 
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
 */
15
19
 
16
20
/**
17
21
  @file
18
22
 
19
23
  It is interface module to fixed precision decimals library.
20
24
 
21
 
  Most functions use 'uint mask' as parameter, if during operation error
 
25
  Most functions use 'uint32_t mask' as parameter, if during operation error
22
26
  which fit in this mask is detected then it will be processed automatically
23
27
  here. (errors are E_DEC_* constants, see include/decimal.h)
24
28
 
28
32
#ifndef my_decimal_h
29
33
#define my_decimal_h
30
34
 
31
 
C_MODE_START
 
35
#ifdef __cplusplus
 
36
extern "C" {
 
37
#endif
 
38
 
32
39
#include <mystrings/decimal.h>
33
 
C_MODE_END
 
40
#include <mysys/my_time.h>
 
41
#include <drizzled/sql_string.h>
 
42
 
 
43
#ifdef __cplusplus
 
44
}
 
45
#endif
 
46
 
34
47
 
35
48
#define DECIMAL_LONGLONG_DIGITS 22
36
49
#define DECIMAL_LONG_DIGITS 10
65
78
#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
66
79
 
67
80
 
68
 
inline uint my_decimal_size(uint precision, uint scale)
 
81
inline uint32_t my_decimal_size(uint32_t precision, uint32_t scale)
69
82
{
70
83
  /*
71
84
    Always allocate more space to allow library to put decimal point
75
88
}
76
89
 
77
90
 
78
 
inline int my_decimal_int_part(uint precision, uint decimals)
 
91
inline int my_decimal_int_part(uint32_t precision, uint32_t decimals)
79
92
{
80
93
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
81
94
}
99
112
  {
100
113
    len= DECIMAL_BUFF_LENGTH;
101
114
    buf= buffer;
102
 
#if !defined (HAVE_purify) 
 
115
#if !defined (HAVE_purify)
103
116
    /* Set buffer to 'random' value to find wrong buffer usage */
104
 
    for (uint i= 0; i < DECIMAL_BUFF_LENGTH; i++)
 
117
    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
105
118
      buffer[i]= i;
106
119
#endif
107
120
  }
113
126
 
114
127
  bool sign() const { return decimal_t::sign; }
115
128
  void sign(bool s) { decimal_t::sign= s; }
116
 
  uint precision() const { return intg + frac; }
 
129
  uint32_t precision() const { return intg + frac; }
117
130
};
118
131
 
119
 
#ifndef DRIZZLE_CLIENT
120
132
int decimal_operation_results(int result);
121
 
#else
122
 
inline int decimal_operation_results(int result)
123
 
{
124
 
  return result;
125
 
}
126
 
#endif /*DRIZZLE_CLIENT*/
127
133
 
128
134
inline
129
135
void max_my_decimal(my_decimal *to, int precision, int frac)
138
144
  max_my_decimal(to, DECIMAL_MAX_PRECISION, 0);
139
145
}
140
146
 
141
 
inline int check_result(uint mask, int result)
 
147
inline int check_result(uint32_t mask, int result)
142
148
{
143
149
  if (result & mask)
144
150
    decimal_operation_results(result);
145
151
  return result;
146
152
}
147
153
 
148
 
inline int check_result_and_overflow(uint mask, int result, my_decimal *val)
 
154
inline int check_result_and_overflow(uint32_t mask, int result, my_decimal *val)
149
155
{
150
156
  if (check_result(mask, result) & E_DEC_OVERFLOW)
151
157
  {
157
163
  return result;
158
164
}
159
165
 
160
 
inline uint my_decimal_length_to_precision(uint length, uint scale,
 
166
inline uint32_t my_decimal_length_to_precision(uint32_t length, uint32_t scale,
161
167
                                           bool unsigned_flag)
162
168
{
163
169
  return (uint) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
164
170
}
165
171
 
166
 
inline uint32_t my_decimal_precision_to_length(uint precision, uint8_t scale,
 
172
inline uint32_t my_decimal_precision_to_length(uint32_t precision, uint8_t scale,
167
173
                                             bool unsigned_flag)
168
174
{
169
175
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
186
192
 
187
193
 
188
194
inline
189
 
int my_decimal_get_binary_size(uint precision, uint scale)
 
195
int my_decimal_get_binary_size(uint32_t precision, uint32_t scale)
190
196
{
191
197
  return decimal_bin_size((int)precision, (int)scale);
192
198
}
200
206
}
201
207
 
202
208
 
203
 
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
 
209
int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
204
210
                      int scale);
205
211
 
206
212
 
207
213
inline
208
 
int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d, int prec,
 
214
int binary2my_decimal(uint32_t mask, const unsigned char *bin, my_decimal *d, int prec,
209
215
                      int scale)
210
216
{
211
217
  return check_result(mask, bin2decimal(bin, (decimal_t*) d, prec, scale));
228
234
 
229
235
 
230
236
inline
231
 
int my_decimal_round(uint mask, const my_decimal *from, int scale,
 
237
int my_decimal_round(uint32_t mask, const my_decimal *from, int scale,
232
238
                     bool truncate, my_decimal *to)
233
239
{
234
240
  return check_result(mask, decimal_round((decimal_t*) from, to, scale,
235
 
                                          (truncate ? TRUNCATE : HALF_UP)));
 
241
                                          (truncate ? TRUNCATE : HALF_UP)));
236
242
}
237
243
 
238
244
 
239
245
inline
240
 
int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to)
 
246
int my_decimal_floor(uint32_t mask, const my_decimal *from, my_decimal *to)
241
247
{
242
248
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, FLOOR));
243
249
}
244
250
 
245
251
 
246
252
inline
247
 
int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to)
 
253
int my_decimal_ceiling(uint32_t mask, const my_decimal *from, my_decimal *to)
248
254
{
249
255
  return check_result(mask, decimal_round((decimal_t*) from, to, 0, CEILING));
250
256
}
251
257
 
252
258
 
253
 
#ifndef DRIZZLE_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
int my_decimal2string(uint32_t mask, const my_decimal *d, uint32_t fixed_prec,
 
260
                      uint32_t fixed_dec, char filler, String *str);
257
261
 
258
262
inline
259
 
int my_decimal2int(uint mask, const my_decimal *d, bool unsigned_flag,
260
 
                   int64_t *l)
 
263
int my_decimal2int(uint32_t mask, const my_decimal *d, bool unsigned_flag,
 
264
                   int64_t *l)
261
265
{
262
266
  my_decimal rounded;
263
267
  /* decimal_round can return only E_DEC_TRUNCATED */
269
273
 
270
274
 
271
275
inline
272
 
int my_decimal2double(uint mask __attribute__((unused)), 
273
 
                      const my_decimal *d, double *result)
 
276
int my_decimal2double(uint32_t, const my_decimal *d, double *result)
274
277
{
275
278
  /* No need to call check_result as this will always succeed */
276
279
  return decimal2double((decimal_t*) d, result);
278
281
 
279
282
 
280
283
inline
281
 
int str2my_decimal(uint mask, char *str, my_decimal *d, char **end)
 
284
int str2my_decimal(uint32_t mask, char *str, my_decimal *d, char **end)
282
285
{
283
286
  return check_result_and_overflow(mask, string2decimal(str,(decimal_t*)d,end),
284
287
                                   d);
285
288
}
286
289
 
287
290
 
288
 
int str2my_decimal(uint mask, const char *from, uint length,
 
291
int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
289
292
                   const CHARSET_INFO * charset, my_decimal *decimal_value);
290
293
 
291
 
#if defined(DRIZZLE_SERVER)
292
294
inline
293
 
int string2my_decimal(uint mask, const String *str, my_decimal *d)
 
295
int string2my_decimal(uint32_t mask, const String *str, my_decimal *d)
294
296
{
295
297
  return str2my_decimal(mask, str->ptr(), str->length(), str->charset(), d);
296
298
}
299
301
my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec);
300
302
 
301
303
 
302
 
#endif /*defined(DRIZZLE_SERVER) */
303
 
 
304
304
inline
305
 
int double2my_decimal(uint mask, double val, my_decimal *d)
 
305
int double2my_decimal(uint32_t mask, double val, my_decimal *d)
306
306
{
307
307
  return check_result_and_overflow(mask, double2decimal(val, (decimal_t*)d), d);
308
308
}
309
309
 
310
310
 
311
311
inline
312
 
int int2my_decimal(uint mask, int64_t i, bool unsigned_flag, my_decimal *d)
 
312
int int2my_decimal(uint32_t mask, int64_t i, bool unsigned_flag, my_decimal *d)
313
313
{
314
314
  return check_result(mask, (unsigned_flag ?
315
315
                             uint64_t2decimal((uint64_t)i, d) :
330
330
 
331
331
 
332
332
inline
333
 
int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a,
 
333
int my_decimal_add(uint32_t mask, my_decimal *res, const my_decimal *a,
334
334
                   const my_decimal *b)
335
335
{
336
336
  return check_result_and_overflow(mask,
340
340
 
341
341
 
342
342
inline
343
 
int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a,
 
343
int my_decimal_sub(uint32_t mask, my_decimal *res, const my_decimal *a,
344
344
                   const my_decimal *b)
345
345
{
346
346
  return check_result_and_overflow(mask,
350
350
 
351
351
 
352
352
inline
353
 
int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a,
 
353
int my_decimal_mul(uint32_t mask, my_decimal *res, const my_decimal *a,
354
354
                   const my_decimal *b)
355
355
{
356
356
  return check_result_and_overflow(mask,
360
360
 
361
361
 
362
362
inline
363
 
int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a,
 
363
int my_decimal_div(uint32_t mask, my_decimal *res, const my_decimal *a,
364
364
                   const my_decimal *b, int div_scale_inc)
365
365
{
366
366
  return check_result_and_overflow(mask,
371
371
 
372
372
 
373
373
inline
374
 
int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a,
 
374
int my_decimal_mod(uint32_t mask, my_decimal *res, const my_decimal *a,
375
375
                   const my_decimal *b)
376
376
{
377
377
  return check_result_and_overflow(mask,
398
398
}
399
399
 
400
400
 
401
 
void my_decimal_trim(uint32_t *precision, uint *scale);
 
401
void my_decimal_trim(uint32_t *precision, uint32_t *scale);
402
402
 
403
403
 
404
404
#endif /*my_decimal_h*/