← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/decimal.h

  • Committer: Monty Taylor
  • Date: 2010-12-24 02:13:05 UTC
  • mto: This revision was merged to the branch mainline in revision 2038.
  • Revision ID: mordred@inaugust.com-20101224021305-e3slv1cyjczqorij
Changed the bzrignore file.

Show diffs side-by-side

added added

removed removed

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