← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/decimal.h

  • Committer: Jay Pipes
  • Date: 2009-09-15 21:01:42 UTC
  • mto: (1126.2.5 merge)
  • mto: This revision was merged to the branch mainline in revision 1128.
  • Revision ID: jpipes@serialcoder-20090915210142-x8mwiqn1q0vzjspp
Moves Alter_info out into its own header and source file, cleans up some related include mess in sql_lex.h, and renames Alter_info to AlterInfo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/decimal.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
#ifndef DRIZZLED_TYPE_DECIMAL_H
17
 
#define DRIZZLED_TYPE_DECIMAL_H
18
 
#include <assert.h>
19
 
#include <drizzled/sql_string.h>
20
 
#include "drizzled/definitions.h"
21
 
#include "drizzled/type/time.h"
22
 
namespace drizzled
23
 
{
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#ifndef _decimal_h
 
17
#define _decimal_h
 
18
 
 
19
#if defined(__cplusplus)
 
20
extern "C" {
 
21
#endif
24
22
 
25
23
typedef enum
26
 
{
27
 
  TRUNCATE= 0,
28
 
  HALF_EVEN,
29
 
  HALF_UP,
30
 
  CEILING,
31
 
  FLOOR
32
 
} decimal_round_mode;
 
24
{TRUNCATE=0, HALF_EVEN, HALF_UP, CEILING, FLOOR}
 
25
  decimal_round_mode;
33
26
typedef int32_t decimal_digit_t;
34
27
 
35
 
struct decimal_t {
 
28
typedef struct st_decimal_t {
36
29
  int    intg, frac, len;
37
30
  bool sign;
38
31
  decimal_digit_t *buf;
39
 
 
40
 
  /* set a decimal_t to zero */
41
 
  inline void set_zero()
42
 
  {                                                         
43
 
    buf[0]= 0;
44
 
    intg= 1;
45
 
    frac= 0;
46
 
    sign= 0; 
47
 
  }
48
 
 
49
 
  /* negate a decimal */
50
 
  inline void negate()
51
 
  {
52
 
    sign^=1;
53
 
  }
54
 
 
55
 
  int isZero() const;
56
 
 
57
 
};
 
32
} decimal_t;
58
33
 
59
34
int internal_str2dec(char *from, decimal_t *to, char **end,
60
35
                     bool fixed);
61
 
int decimal2string(const decimal_t *from, char *to, int *to_len,
 
36
int decimal2string(decimal_t *from, char *to, int *to_len,
62
37
                   int fixed_precision, int fixed_decimals,
63
38
                   char filler);
64
 
int decimal2uint64_t(const decimal_t *from, uint64_t *to);
65
 
int uint64_t2decimal(const uint64_t from, decimal_t *to);
66
 
int decimal2int64_t(const decimal_t *from, int64_t *to);
67
 
int int64_t2decimal(const int64_t from, decimal_t *to);
68
 
int decimal2double(const decimal_t *from, double *to);
69
 
int double2decimal(const double from, decimal_t *to);
 
39
int decimal2uint64_t(decimal_t *from, uint64_t *to);
 
40
int uint64_t2decimal(uint64_t from, decimal_t *to);
 
41
int decimal2int64_t(decimal_t *from, int64_t *to);
 
42
int int64_t2decimal(int64_t from, decimal_t *to);
 
43
int decimal2double(decimal_t *from, double *to);
 
44
int double2decimal(double from, decimal_t *to);
70
45
int decimal_actual_fraction(decimal_t *from);
71
 
int decimal2bin(const decimal_t *from, unsigned char *to, int precision, int scale);
 
46
int decimal2bin(decimal_t *from, unsigned char *to, int precision, int scale);
72
47
int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale);
73
48
 
 
49
int decimal_size(int precision, int scale);
74
50
int decimal_bin_size(int precision, int scale);
 
51
int decimal_result_size(decimal_t *from1, decimal_t *from2, char op,
 
52
                        int param);
75
53
 
76
 
int decimal_intg(const decimal_t *from);
77
 
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
78
 
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
79
 
int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
80
 
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
81
 
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
 
54
int decimal_intg(decimal_t *from);
 
55
int decimal_add(decimal_t *from1, decimal_t *from2, decimal_t *to);
 
56
int decimal_sub(decimal_t *from1, decimal_t *from2, decimal_t *to);
 
57
int decimal_cmp(decimal_t *from1, decimal_t *from2);
 
58
int decimal_mul(decimal_t *from1, decimal_t *from2, decimal_t *to);
 
59
int decimal_div(decimal_t *from1, decimal_t *from2, decimal_t *to,
82
60
                int scale_incr);
83
 
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
84
 
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
 
61
int decimal_mod(decimal_t *from1, decimal_t *from2, decimal_t *to);
 
62
int decimal_round(decimal_t *from, decimal_t *to, int new_scale,
85
63
                  decimal_round_mode mode);
 
64
int decimal_is_zero(decimal_t *from);
86
65
void max_decimal(int precision, int frac, decimal_t *to);
87
66
 
88
 
inline int string2decimal(char *from, decimal_t *to, char **end)
89
 
{
90
 
  return internal_str2dec(from, to, end, false);
91
 
}
 
67
#define string2decimal(A,B,C) internal_str2dec((A), (B), (C), 0)
 
68
#define string2decimal_fixed(A,B,C) internal_str2dec((A), (B), (C), 1)
 
69
 
 
70
/* set a decimal_t to zero */
 
71
 
 
72
#define decimal_make_zero(dec)        do {                \
 
73
                                        (dec)->buf[0]=0;    \
 
74
                                        (dec)->intg=1;      \
 
75
                                        (dec)->frac=0;      \
 
76
                                        (dec)->sign=0;      \
 
77
                                      } while(0)
92
78
 
93
79
/*
94
80
  returns the length of the buffer to hold string representation
95
81
  of the decimal (including decimal dot, possible sign and \0)
96
82
*/
97
83
 
98
 
inline int decimal_string_size(const decimal_t *dec)
99
 
{
100
 
  return (dec->intg ? dec->intg : 1) + dec->frac + (dec->frac > 0) + 2;
101
 
}
 
84
#define decimal_string_size(dec) (((dec)->intg ? (dec)->intg : 1) + \
 
85
                                  (dec)->frac + ((dec)->frac > 0) + 2)
 
86
 
 
87
/* negate a decimal */
 
88
#define decimal_neg(dec) do { (dec)->sign^=1; } while(0)
102
89
 
103
90
/*
104
91
  conventions:
120
107
#define E_DEC_ERROR            31
121
108
#define E_DEC_FATAL_ERROR      30
122
109
 
123
 
 
124
 
#define DECIMAL_LONGLONG_DIGITS 22
125
 
#define DECIMAL_LONG_DIGITS 10
126
 
#define DECIMAL_LONG3_DIGITS 8
127
 
 
128
 
/** maximum length of buffer in our big digits (uint32_t). */
129
 
#define DECIMAL_BUFF_LENGTH 9
130
 
 
131
 
/* the number of digits that type::Decimal can possibly contain */
132
 
#define DECIMAL_MAX_POSSIBLE_PRECISION (DECIMAL_BUFF_LENGTH * 9)
133
 
 
134
 
 
135
 
/**
136
 
  maximum guaranteed precision of number in decimal digits (number of our
137
 
  digits * number of decimal digits in one our big digit - number of decimal
138
 
  digits in one our big digit decreased by 1 (because we always put decimal
139
 
  point on the border of our big digits))
140
 
*/
141
 
#define DECIMAL_MAX_PRECISION (DECIMAL_MAX_POSSIBLE_PRECISION - 8*2)
142
 
#define DECIMAL_MAX_SCALE 30
143
 
#define DECIMAL_NOT_SPECIFIED 31
144
 
 
145
 
/**
146
 
  maximum length of string representation (number of maximum decimal
147
 
  digits + 1 position for sign + 1 position for decimal point)
148
 
*/
149
 
#define DECIMAL_MAX_STR_LENGTH (DECIMAL_MAX_POSSIBLE_PRECISION + 2)
150
 
 
151
 
/**
152
 
  maximum size of packet length.
153
 
*/
154
 
#define DECIMAL_MAX_FIELD_SIZE DECIMAL_MAX_PRECISION
155
 
 
156
 
namespace type {
157
 
class Decimal;
158
 
}
159
 
 
160
 
inline int class_decimal_int_part(uint32_t precision, uint32_t decimals)
161
 
{
162
 
  return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
163
 
}
164
 
 
165
 
int decimal_operation_results(int result);
166
 
 
167
 
inline void max_Decimal(type::Decimal *to, int precision, int frac)
168
 
{
169
 
  assert((precision <= DECIMAL_MAX_PRECISION)&&
170
 
              (frac <= DECIMAL_MAX_SCALE));
171
 
  max_decimal(precision, frac, (decimal_t*) to);
172
 
}
173
 
 
174
 
inline void max_internal_decimal(type::Decimal *to)
175
 
{
176
 
  max_Decimal(to, DECIMAL_MAX_PRECISION, 0);
177
 
}
178
 
 
179
 
inline int check_result(uint32_t mask, int result)
180
 
{
181
 
  if (result & mask)
182
 
    decimal_operation_results(result);
183
 
  return result;
184
 
}
185
 
 
186
 
namespace type {
187
 
/**
188
 
  type Decimal class limits 'decimal_t' type to what we need in MySQL.
189
 
 
190
 
  It contains internally all necessary space needed by the instance so
191
 
  no extra memory is needed. One should call fix_buffer_pointer() function
192
 
  when he moves type::Decimal objects in memory.
193
 
*/
194
 
 
195
 
class Decimal : public decimal_t
196
 
{
197
 
  decimal_digit_t buffer[DECIMAL_BUFF_LENGTH];
198
 
 
199
 
public:
200
 
 
201
 
  void init()
202
 
  {
203
 
    len= DECIMAL_BUFF_LENGTH;
204
 
    buf= buffer;
205
 
#if !defined (HAVE_VALGRIND)
206
 
    /* Set buffer to 'random' value to find wrong buffer usage */
207
 
    for (uint32_t i= 0; i < DECIMAL_BUFF_LENGTH; i++)
208
 
      buffer[i]= i;
209
 
#endif
210
 
  }
211
 
 
212
 
  Decimal()
213
 
  {
214
 
    init();
215
 
  }
216
 
 
217
 
  void fix_buffer_pointer() { buf= buffer; }
218
 
  bool sign() const { return decimal_t::sign; }
219
 
  void sign(bool s) { decimal_t::sign= s; }
220
 
  uint32_t precision() const { return intg + frac; }
221
 
 
222
 
  int val_int32(uint32_t mask, bool unsigned_flag, int64_t *l) const
223
 
  {
224
 
    type::Decimal rounded;
225
 
    /* decimal_round can return only E_DEC_TRUNCATED */
226
 
    decimal_round(static_cast<const decimal_t*>(this), &rounded, 0, HALF_UP);
227
 
    return check_result(mask, (unsigned_flag ?
228
 
                               decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
229
 
                               decimal2int64_t(&rounded, l)));
230
 
  }
231
 
 
232
 
  int string_length() const
233
 
  {
234
 
    return decimal_string_size(this);
235
 
  }
236
 
 
237
 
  int val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const;
238
 
 
239
 
  int store(uint32_t mask, const char *from, uint32_t length, const CHARSET_INFO * charset);
240
 
 
241
 
  int store(uint32_t mask, char *str, char **end)
242
 
  {
243
 
    return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(this), end));
244
 
  }
245
 
 
246
 
  int store(uint32_t mask, const String *str)
247
 
  {
248
 
    return store(mask, str->ptr(), str->length(), str->charset());
249
 
  }
250
 
 
251
 
  int check_result_and_overflow(uint32_t mask, int result)
252
 
  {
253
 
    if (check_result(mask, result) & E_DEC_OVERFLOW)
254
 
    {
255
 
      bool _sign= sign();
256
 
      fix_buffer_pointer();
257
 
      max_internal_decimal(this);
258
 
      sign(_sign);
259
 
    }
260
 
    return result;
261
 
  }
262
 
 
263
 
  void convert(double &value) const;
264
 
};
265
 
 
266
 
} // type
267
 
 
268
 
std::ostream& operator<<(std::ostream& output, const type::Decimal &dec);
269
 
 
270
 
inline uint32_t class_decimal_length_to_precision(uint32_t length, uint32_t scale,
271
 
                                                  bool unsigned_flag)
272
 
{
273
 
  return (uint32_t) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
274
 
}
275
 
 
276
 
inline uint32_t class_decimal_precision_to_length(uint32_t precision, uint8_t scale,
277
 
                                                  bool unsigned_flag)
278
 
{
279
 
  set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
280
 
  return static_cast<uint32_t>(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
281
 
}
282
 
 
283
 
 
284
 
inline
285
 
int class_decimal_max_length(const type::Decimal *d)
286
 
{
287
 
  /* -1 because we do not count \0 */
288
 
  return decimal_string_size(d) - 1;
289
 
}
290
 
 
291
 
 
292
 
inline
293
 
int class_decimal_get_binary_size(uint32_t precision, uint32_t scale)
294
 
{
295
 
  return decimal_bin_size(static_cast<int>(precision), static_cast<int>(scale));
296
 
}
297
 
 
298
 
 
299
 
inline
300
 
void class_decimal2decimal(const type::Decimal *from, type::Decimal *to)
301
 
{
302
 
  *to= *from;
303
 
  to->fix_buffer_pointer();
304
 
}
305
 
 
306
 
 
307
 
inline
308
 
int binary2_class_decimal(uint32_t mask, const unsigned char *bin, type::Decimal *d, int prec,
309
 
                      int scale)
310
 
{
311
 
  return check_result(mask, bin2decimal(bin, static_cast<decimal_t*>(d), prec, scale));
312
 
}
313
 
 
314
 
 
315
 
inline
316
 
int class_decimal_round(uint32_t mask, const type::Decimal *from, int scale,
317
 
                     bool truncate, type::Decimal *to)
318
 
{
319
 
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, scale,
320
 
                                          (truncate ? TRUNCATE : HALF_UP)));
321
 
}
322
 
 
323
 
 
324
 
inline
325
 
int class_decimal_floor(uint32_t mask, const type::Decimal *from, type::Decimal *to)
326
 
{
327
 
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, FLOOR));
328
 
}
329
 
 
330
 
 
331
 
inline
332
 
int class_decimal_ceiling(uint32_t mask, const type::Decimal *from, type::Decimal *to)
333
 
{
334
 
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, CEILING));
335
 
}
336
 
 
337
 
 
338
 
int class_decimal2string(const type::Decimal *d,
339
 
                         uint32_t fixed_dec, String *str);
340
 
 
341
 
 
342
 
inline
343
 
int class_decimal2double(uint32_t, const type::Decimal *d, double *result)
344
 
{
345
 
  /* No need to call check_result as this will always succeed */
346
 
  return decimal2double(static_cast<const decimal_t*>(d), result);
347
 
}
348
 
 
349
 
 
350
 
type::Decimal *date2_class_decimal(type::Time *ltime, type::Decimal *dec);
351
 
 
352
 
 
353
 
inline
354
 
int double2_class_decimal(uint32_t mask, double val, type::Decimal *d)
355
 
{
356
 
  return d->check_result_and_overflow(mask, double2decimal(val, static_cast<decimal_t*>(d)));
357
 
}
358
 
 
359
 
 
360
 
inline
361
 
int int2_class_decimal(uint32_t mask, int64_t i, bool unsigned_flag, type::Decimal *d)
362
 
{
363
 
  return check_result(mask, (unsigned_flag ?
364
 
                             uint64_t2decimal(static_cast<uint64_t>(i), d) :
365
 
                             int64_t2decimal(i, d)));
366
 
}
367
 
 
368
 
 
369
 
inline
370
 
void class_decimal_neg(decimal_t *arg)
371
 
{
372
 
  if (arg->isZero())
373
 
  {
374
 
    arg->sign= 0;
375
 
    return;
376
 
  }
377
 
  arg->negate();
378
 
}
379
 
 
380
 
 
381
 
inline
382
 
int class_decimal_add(uint32_t mask, type::Decimal *res, const type::Decimal *a,
383
 
                   const type::Decimal *b)
384
 
{
385
 
  return res->check_result_and_overflow(mask,
386
 
                                        decimal_add(static_cast<const decimal_t*>(a),
387
 
                                                    static_cast<const decimal_t*>(b), res));
388
 
}
389
 
 
390
 
 
391
 
inline
392
 
int class_decimal_sub(uint32_t mask, type::Decimal *res, const type::Decimal *a,
393
 
                   const type::Decimal *b)
394
 
{
395
 
  return res->check_result_and_overflow(mask,
396
 
                                        decimal_sub(static_cast<const decimal_t*>(a),
397
 
                                                    static_cast<const decimal_t*>(b), res));
398
 
}
399
 
 
400
 
 
401
 
inline
402
 
int class_decimal_mul(uint32_t mask, type::Decimal *res, const type::Decimal *a,
403
 
                   const type::Decimal *b)
404
 
{
405
 
  return res->check_result_and_overflow(mask,
406
 
                                        decimal_mul(static_cast<const decimal_t*>(a),
407
 
                                                    static_cast<const decimal_t*>(b),res));
408
 
}
409
 
 
410
 
 
411
 
inline
412
 
int class_decimal_div(uint32_t mask, type::Decimal *res, const type::Decimal *a,
413
 
                   const type::Decimal *b, int div_scale_inc)
414
 
{
415
 
  return res->check_result_and_overflow(mask,
416
 
                                        decimal_div(static_cast<const decimal_t*>(a),
417
 
                                                    static_cast<const decimal_t*>(b),res,
418
 
                                                    div_scale_inc));
419
 
}
420
 
 
421
 
 
422
 
inline
423
 
int class_decimal_mod(uint32_t mask, type::Decimal *res, const type::Decimal *a,
424
 
                   const type::Decimal *b)
425
 
{
426
 
  return res->check_result_and_overflow(mask,
427
 
                                        decimal_mod(static_cast<const decimal_t*>(a),
428
 
                                                    static_cast<const decimal_t*>(b),res));
429
 
}
430
 
 
431
 
 
432
 
/**
433
 
  @return
434
 
    -1 if a<b, 1 if a>b and 0 if a==b
435
 
*/
436
 
inline
437
 
int class_decimal_cmp(const type::Decimal *a, const type::Decimal *b)
438
 
{
439
 
  return decimal_cmp(static_cast<const decimal_t*>(a),
440
 
                     static_cast<const decimal_t*>(b));
441
 
}
442
 
 
443
 
 
444
 
inline
445
 
int class_decimal_intg(const type::Decimal *a)
446
 
{
447
 
  return decimal_intg(static_cast<const decimal_t*>(a));
448
 
}
449
 
 
450
 
 
451
 
void class_decimal_trim(uint32_t *precision, uint32_t *scale);
452
 
 
453
 
inline type::Decimal &decimal_zero_const()
454
 
{
455
 
  static type::Decimal _decimal_zero;
456
 
  return _decimal_zero;
457
 
}
458
 
 
459
 
double my_double_round(double value, int64_t dec, bool dec_unsigned,
460
 
                       bool truncate);
461
 
 
462
 
 
463
 
#define decimal_zero decimal_zero_const()
464
 
 
465
 
} /* namespace drizzled */
466
 
 
467
 
#endif /* DRIZZLED_TYPE_DECIMAL_H */
 
110
#if defined(__cplusplus)
 
111
}
 
112
#endif
 
113
 
 
114
#endif
468
115