← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/decimal.h

  • Committer: Brian Aker
  • Date: 2010-08-09 18:04:12 UTC
  • mfrom: (1689.3.7 staging)
  • Revision ID: brian@gaz-20100809180412-olurwh51ojllev6p
Merge in heap conversion, and case insensitive patch, and remove need for
M_HASH in session.

Show diffs side-by-side

added added

removed removed

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