MySQL 8.0.31
Source Code Documentation
my_decimal.h
Go to the documentation of this file.
1/* Copyright (c) 2005, 2022, Oracle and/or its affiliates.
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, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef MY_DECIMAL_INCLUDED
24#define MY_DECIMAL_INCLUDED
25
26/**
27 @file
28
29 It is interface module to fixed precision decimals library.
30
31 Most functions use 'uint mask' as parameter, if during operation error
32 which fit in this mask is detected then it will be processed automatically
33 here. (errors are E_DEC_* constants, see include/decimal.h)
34
35 Most function are just inline wrappers around library calls
36*/
37
38#include <assert.h>
39#include <stdlib.h>
40#include <sys/types.h>
41#include <algorithm>
42
43#include "decimal.h"
44#include "m_ctype.h"
45
46#include "my_inttypes.h"
47#include "my_macros.h"
48#include "my_time_t.h"
49
50class String;
51struct MYSQL_TIME;
52
53static constexpr int DECIMAL_LONGLONG_DIGITS{22};
54
55/** maximum length of buffer in our big digits (uint32). */
56static constexpr int DECIMAL_BUFF_LENGTH{9};
57
58/** the number of digits that my_decimal can possibly contain */
60
61/**
62 maximum guaranteed precision of number in decimal digits (number of our
63 digits * number of decimal digits in one our big digit - number of decimal
64 digits in one our big digit decreased by 1 (because we always put decimal
65 point on the border of our big digits))
66*/
68 8 * 2};
69
70/**
71 maximum length of string representation (number of maximum decimal
72 digits + 1 position for sign + 1 position for decimal point, no terminator)
73*/
75
76/**
77 maximum size of packet length.
78*/
80
81inline int my_decimal_int_part(uint precision, uint decimals) {
82 return precision - ((decimals == DECIMAL_NOT_SPECIFIED) ? 0 : decimals);
83}
84
85/**
86 my_decimal class limits 'decimal_t' type to what we need in MySQL.
87
88 It contains internally all necessary space needed by the instance so
89 no extra memory is needed. Objects should be moved using copy CTOR
90 or assignment operator, rather than memcpy/memmove.
91*/
92
93class my_decimal : public decimal_t {
94/*
95 Several of the routines in strings/decimal.c have had buffer
96 overrun/underrun problems. These are *not* caught by valgrind.
97 To catch them, we allocate dummy fields around the buffer,
98 and test that their values do not change.
99 */
100#if !defined(NDEBUG)
101 int foo1;
102#endif
103
105
106#if !defined(NDEBUG)
107 int foo2;
108 static const int test_value = 123;
109#endif
110
111 public:
112 my_decimal(const my_decimal &rhs) : decimal_t(rhs) {
113 rhs.sanity_check();
114#if !defined(NDEBUG)
117#endif
118 for (uint i = 0; i < DECIMAL_BUFF_LENGTH; i++) buffer[i] = rhs.buffer[i];
119 buf = buffer;
120 }
121
123 sanity_check();
124 rhs.sanity_check();
125 if (this == &rhs) return *this;
126 decimal_t::operator=(rhs);
127 for (uint i = 0; i < DECIMAL_BUFF_LENGTH; i++) buffer[i] = rhs.buffer[i];
128 buf = buffer;
129 return *this;
130 }
131
132 void init() {
133#if !defined(NDEBUG)
136#endif
137 /*
138 Do not initialize more of the base class,
139 we want to catch uninitialized use.
140 */
142 buf = buffer;
143 }
144
146
147#ifndef NDEBUG
149#endif // NDEBUG
150
151 void sanity_check() const {
152 assert(foo1 == test_value);
153 assert(foo2 == test_value);
154 assert(buf == buffer);
155 }
156
157 bool sign() const { return decimal_t::sign; }
158 void sign(bool s) { decimal_t::sign = s; }
159 uint precision() const { return intg + frac; }
160
161 /** Swap two my_decimal values */
162 void swap(my_decimal &rhs) { std::swap(*this, rhs); }
163
164#ifndef MYSQL_SERVER
165 // Error reporting in server code only.
166 int check_result(uint, int result) const { return result; }
167#else
168 int check_result(uint, int result) const;
169#endif
170};
171
172#ifndef NDEBUG
173void print_decimal(const my_decimal *dec);
174void print_decimal_buff(const my_decimal *dec, const uchar *ptr, int length);
175const char *dbug_decimal_as_string(char *buff, const my_decimal *val);
176#else
177#define dbug_decimal_as_string(A) NULL
178#endif
179
180bool str_set_decimal(uint mask, const my_decimal *val, String *str,
181 const CHARSET_INFO *cs, uint decimals);
182
184
185inline void max_my_decimal(my_decimal *to, int precision, int frac) {
186 assert((precision <= DECIMAL_MAX_PRECISION) && (frac <= DECIMAL_MAX_SCALE));
187 max_decimal(precision, frac, to);
188}
189
192}
193
195 if (val->check_result(mask, result) & E_DEC_OVERFLOW) {
196 bool sign = val->sign();
197 val->sanity_check();
199 val->sign(sign);
200 }
201 /*
202 Avoid returning negative zero, cfr. decimal_cmp()
203 For result == E_DEC_DIV_ZERO *val has not been assigned.
204 */
205 if (result != E_DEC_DIV_ZERO && val->sign() && decimal_is_zero(val))
206 val->sign(false);
207 return result;
208}
209
211 bool unsigned_flag) {
212 /* Precision can't be negative thus ignore unsigned_flag when length is 0. */
213 assert(length || !scale);
214 uint retval =
215 (uint)(length - (scale > 0 ? 1 : 0) - (unsigned_flag || !length ? 0 : 1));
216 return retval;
217}
218
220 uint8 scale,
221 bool unsigned_flag) {
222 /*
223 When precision is 0 it means that original length was also 0. Thus
224 unsigned_flag is ignored in this case.
225 */
226 assert(precision || !scale);
227 uint32 retval = (uint32)(precision + (scale > 0 ? 1 : 0) +
228 (unsigned_flag || !precision ? 0 : 1));
229 if (retval == 0) return 1;
230 return retval;
231}
232
234 bool unsigned_flag) {
235 /*
236 When precision is 0 it means that original length was also 0. Thus
237 unsigned_flag is ignored in this case.
238 */
239 assert(precision || !scale);
240 precision = std::min(precision, uint(DECIMAL_MAX_PRECISION));
241 return my_decimal_precision_to_length_no_truncation(precision, scale,
242 unsigned_flag);
243}
244
246 /* length of string representation including terminating '\0' */
247 return decimal_string_size(d);
248}
249
250inline int my_decimal_get_binary_size(uint precision, uint scale) {
251 return decimal_bin_size((int)precision, (int)scale);
252}
253
254inline void my_decimal2decimal(const my_decimal *from, my_decimal *to) {
255 *to = *from;
256}
257
258int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
259 int scale);
260
261inline int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d,
262 int prec, int scale) {
263 return d->check_result(mask, bin2decimal(bin, d, prec, scale, false));
264}
265
266/**
267 Decode DECIMAL from binary form
268
269 @param mask Error mask
270 @param bin Binary string to decode
271 @param d [out] DECIMAL buffer
272 @param prec Precision of stored value
273 @param scale Scale of stored value
274 @param keep_prec Whether to keep stored value's precision
275
276 @returns
277 conversion error
278*/
279
280inline int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d,
281 int prec, int scale, bool keep_prec) {
282 return d->check_result(mask, bin2decimal(bin, d, prec, scale, keep_prec));
283}
284
286 /*
287 We need the up-cast here, since my_decimal has sign() member functions,
288 which conflicts with decimal_t::size
289 (and decimal_make_zero is a macro, rather than a function).
290 */
291 decimal_make_zero(static_cast<decimal_t *>(d));
292 return 0;
293}
294
295inline bool my_decimal_is_zero(const my_decimal *decimal_value) {
296 return decimal_is_zero(decimal_value);
297}
298
299inline int my_decimal_round(uint mask, const my_decimal *from, int scale,
300 bool truncate, my_decimal *to) {
301 return from->check_result(
302 mask, decimal_round(from, to, scale, (truncate ? TRUNCATE : HALF_UP)));
303}
304
305inline int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to) {
306 return from->check_result(mask, decimal_round(from, to, 0, FLOOR));
307}
308
309inline int my_decimal_ceiling(uint mask, const my_decimal *from,
310 my_decimal *to) {
311 return from->check_result(mask, decimal_round(from, to, 0, CEILING));
312}
313
314int my_decimal2string(uint mask, const my_decimal *d, uint fixed_prec,
315 uint fixed_dec, String *str);
316
318 return my_decimal2string(mask, d, 0, 0, str);
319}
320
321inline int my_decimal2int(uint mask, const my_decimal *d, bool unsigned_flag,
322 longlong *l) {
323 my_decimal rounded;
324 /* decimal_round can return only E_DEC_TRUNCATED */
325 decimal_round(d, &rounded, 0, HALF_UP);
326 return d->check_result(
327 mask, (unsigned_flag ? decimal2ulonglong(&rounded, (ulonglong *)l)
328 : decimal2longlong(&rounded, l)));
329}
330
331inline int my_decimal2double(uint, const my_decimal *d, double *result) {
332 /* No need to call check_result as this will always succeed */
333 return decimal2double(d, result);
334}
335
336inline int my_decimal2lldiv_t(uint mask, const my_decimal *d, lldiv_t *to) {
337 return d->check_result(mask, decimal2lldiv_t(d, to));
338}
339
340inline int str2my_decimal(uint mask, const char *str, my_decimal *d,
341 const char **end) {
343}
344
345int str2my_decimal(uint mask, const char *from, size_t length,
346 const CHARSET_INFO *charset, my_decimal *decimal_value);
347
351
352inline int double2my_decimal(uint mask, double val, my_decimal *d) {
354}
355
356inline int int2my_decimal(uint mask, longlong i, bool unsigned_flag,
357 my_decimal *d) {
358 return d->check_result(mask,
359 (unsigned_flag ? ulonglong2decimal((ulonglong)i, d)
360 : longlong2decimal(i, d)));
361}
362
363inline void my_decimal_neg(decimal_t *arg) {
364 // Avoid returning negative zero, cfr. decimal_cmp()
365 if (decimal_is_zero(arg)) {
366 arg->sign = false;
367 return;
368 }
369 arg->sign ^= 1;
370}
371
372inline int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a,
373 const my_decimal *b) {
374 return check_result_and_overflow(mask, decimal_add(a, b, res), res);
375}
376
377inline int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a,
378 const my_decimal *b) {
379 return check_result_and_overflow(mask, decimal_sub(a, b, res), res);
380}
381
382inline int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a,
383 const my_decimal *b) {
384 return check_result_and_overflow(mask, decimal_mul(a, b, res), res);
385}
386
387inline int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a,
388 const my_decimal *b, int div_scale_inc) {
389 return check_result_and_overflow(mask, decimal_div(a, b, res, div_scale_inc),
390 res);
391}
392
393inline int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a,
394 const my_decimal *b) {
395 return check_result_and_overflow(mask, decimal_mod(a, b, res), res);
396}
397
398/**
399 @retval -1 if a @< b
400 @retval 1 if a @> b
401 @retval 0 if a == b
402*/
403inline int my_decimal_cmp(const my_decimal *a, const my_decimal *b) {
404 return decimal_cmp(a, b);
405}
406
407inline bool operator<(const my_decimal &lhs, const my_decimal &rhs) {
408 return my_decimal_cmp(&lhs, &rhs) < 0;
409}
410
411inline bool operator!=(const my_decimal &lhs, const my_decimal &rhs) {
412 return my_decimal_cmp(&lhs, &rhs) != 0;
413}
414
415inline int my_decimal_intg(const my_decimal *a) { return decimal_intg(a); }
416
417void my_decimal_trim(ulong *precision, uint *scale);
418
419#endif // MY_DECIMAL_INCLUDED
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:166
my_decimal class limits 'decimal_t' type to what we need in MySQL.
Definition: my_decimal.h:93
int check_result(uint, int result) const
report result of decimal operation.
Definition: my_decimal.cc:55
int foo2
Definition: my_decimal.h:107
void sign(bool s)
Definition: my_decimal.h:158
decimal_digit_t buffer[DECIMAL_BUFF_LENGTH]
Definition: my_decimal.h:104
static const int test_value
Definition: my_decimal.h:108
my_decimal()
Definition: my_decimal.h:145
void init()
Definition: my_decimal.h:132
my_decimal & operator=(const my_decimal &rhs)
Definition: my_decimal.h:122
void sanity_check() const
Definition: my_decimal.h:151
int foo1
Definition: my_decimal.h:101
my_decimal(const my_decimal &rhs)
Definition: my_decimal.h:112
uint precision() const
Definition: my_decimal.h:159
~my_decimal()
Definition: my_decimal.h:148
bool sign() const
Definition: my_decimal.h:157
void swap(my_decimal &rhs)
Swap two my_decimal values.
Definition: my_decimal.h:162
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale, decimal_round_mode mode)
Definition: decimal.cc:1656
int decimal_bin_size(int precision, int scale)
Definition: decimal.cc:1634
int decimal2longlong(const decimal_t *from, longlong *to)
Definition: decimal.cc:1177
int ulonglong2decimal(ulonglong from, decimal_t *to)
Definition: decimal.cc:1141
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
Definition: decimal.cc:2086
static int decimal_string_size(const decimal_t *dec)
Returns the length of the buffer to hold string representation of the decimal (including decimal dot,...
Definition: decimal.h:128
int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale, bool keep_prec=false)
Definition: decimal.cc:1488
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
Definition: decimal.cc:2512
@ CEILING
Definition: decimal.h:37
@ FLOOR
Definition: decimal.h:38
@ HALF_UP
Definition: decimal.h:36
@ TRUNCATE
Definition: decimal.h:34
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
Definition: decimal.cc:2037
int decimal_is_zero(const decimal_t *from)
Definition: decimal.cc:2057
#define E_DEC_DIV_ZERO
Definition: decimal.h:144
int longlong2decimal(longlong from, decimal_t *to)
Definition: decimal.cc:1146
int decimal2lldiv_t(const decimal_t *from, lldiv_t *to)
Convert decimal to lldiv_t.
Definition: decimal.cc:1224
static constexpr int DECIMAL_NOT_SPECIFIED
Definition: decimal.h:153
void max_decimal(int precision, int frac, decimal_t *to)
Definition: decimal.cc:428
int32 decimal_digit_t
Definition: decimal.h:40
int decimal2ulonglong(const decimal_t *from, ulonglong *to)
Definition: decimal.cc:1153
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to, int scale_incr)
Definition: decimal.cc:2480
int string2decimal(const char *from, decimal_t *to, const char **end)
Definition: decimal.cc:928
static void decimal_make_zero(decimal_t *dec)
Definition: decimal.h:117
int decimal2double(const decimal_t *from, double *to)
Definition: decimal.cc:1071
int decimal_cmp(const decimal_t *from1, const decimal_t *from2)
Definition: decimal.cc:2047
int decimal_intg(const decimal_t *from)
Returns the number of decimal digits before the decimal point in a decimal_t, with any insignificant ...
Definition: decimal.cc:2031
int double2decimal(double from, decimal_t *to)
Definition: decimal.cc:1100
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
Definition: decimal.cc:2042
#define E_DEC_OVERFLOW
Definition: decimal.h:143
static constexpr int DECIMAL_MAX_SCALE
Definition: decimal.h:152
static const std::string dec("DECRYPTION")
A better implementation of the UNIX ctype(3) library.
static mi_bit_type mask[]
Definition: mi_packrec.cc:140
int my_decimal_int_part(uint precision, uint decimals)
Definition: my_decimal.h:81
int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec, int scale)
Definition: my_decimal.cc:215
void max_internal_decimal(my_decimal *to)
Definition: my_decimal.h:190
int check_result_and_overflow(uint mask, int result, my_decimal *val)
Definition: my_decimal.h:194
int my_decimal_sub(uint mask, my_decimal *res, const my_decimal *a, const my_decimal *b)
Definition: my_decimal.h:377
int int2my_decimal(uint mask, longlong i, bool unsigned_flag, my_decimal *d)
Definition: my_decimal.h:356
void print_decimal_buff(const my_decimal *dec, const uchar *ptr, int length)
Definition: my_decimal.cc:362
my_decimal * timeval2my_decimal(const my_timeval *tm, my_decimal *dec)
Convert timeval value to my_decimal.
Definition: my_decimal.cc:327
int double2my_decimal(uint mask, double val, my_decimal *d)
Definition: my_decimal.h:352
bool operator!=(const my_decimal &lhs, const my_decimal &rhs)
Definition: my_decimal.h:411
void max_my_decimal(my_decimal *to, int precision, int frac)
Definition: my_decimal.h:185
int my_decimal2string(uint mask, const my_decimal *d, uint fixed_prec, uint fixed_dec, String *str)
Converting decimal to string.
Definition: my_decimal.cc:118
static constexpr int DECIMAL_MAX_FIELD_SIZE
maximum size of packet length.
Definition: my_decimal.h:79
int my_decimal_get_binary_size(uint precision, uint scale)
Definition: my_decimal.h:250
static constexpr int DECIMAL_LONGLONG_DIGITS
Definition: my_decimal.h:53
int my_decimal2lldiv_t(uint mask, const my_decimal *d, lldiv_t *to)
Definition: my_decimal.h:336
bool str_set_decimal(uint mask, const my_decimal *val, String *str, const CHARSET_INFO *cs, uint decimals)
Converting decimal to string with character set conversion.
Definition: my_decimal.cc:164
int my_decimal_add(uint mask, my_decimal *res, const my_decimal *a, const my_decimal *b)
Definition: my_decimal.h:372
static constexpr int DECIMAL_BUFF_LENGTH
maximum length of buffer in our big digits (uint32).
Definition: my_decimal.h:56
int my_decimal_mod(uint mask, my_decimal *res, const my_decimal *a, const my_decimal *b)
Definition: my_decimal.h:393
void my_decimal_neg(decimal_t *arg)
Definition: my_decimal.h:363
int my_decimal_floor(uint mask, const my_decimal *from, my_decimal *to)
Definition: my_decimal.h:305
int my_decimal2double(uint, const my_decimal *d, double *result)
Definition: my_decimal.h:331
bool my_decimal_is_zero(const my_decimal *decimal_value)
Definition: my_decimal.h:295
void print_decimal(const my_decimal *dec)
Definition: my_decimal.cc:349
uint my_decimal_length_to_precision(uint length, uint scale, bool unsigned_flag)
Definition: my_decimal.h:210
int binary2my_decimal(uint mask, const uchar *bin, my_decimal *d, int prec, int scale)
Definition: my_decimal.h:261
uint32 my_decimal_precision_to_length(uint precision, uint8 scale, bool unsigned_flag)
Definition: my_decimal.h:233
void my_decimal_trim(ulong *precision, uint *scale)
Definition: my_decimal.cc:334
int my_decimal_cmp(const my_decimal *a, const my_decimal *b)
Definition: my_decimal.h:403
my_decimal * date2my_decimal(const MYSQL_TIME *ltime, my_decimal *dec)
Convert datetime value to my_decimal in format YYYYMMDDhhmmss.ffffff.
Definition: my_decimal.cc:303
bool operator<(const my_decimal &lhs, const my_decimal &rhs)
Definition: my_decimal.h:407
int my_decimal_intg(const my_decimal *a)
Definition: my_decimal.h:415
int my_decimal_set_zero(my_decimal *d)
Definition: my_decimal.h:285
int my_decimal_div(uint mask, my_decimal *res, const my_decimal *a, const my_decimal *b, int div_scale_inc)
Definition: my_decimal.h:387
int my_decimal_round(uint mask, const my_decimal *from, int scale, bool truncate, my_decimal *to)
Definition: my_decimal.h:299
my_decimal * time2my_decimal(const MYSQL_TIME *ltime, my_decimal *dec)
Convert time value to my_decimal in format hhmmss.ffffff.
Definition: my_decimal.cc:317
void my_decimal2decimal(const my_decimal *from, my_decimal *to)
Definition: my_decimal.h:254
static constexpr int DECIMAL_MAX_PRECISION
maximum guaranteed precision of number in decimal digits (number of our digits * number of decimal di...
Definition: my_decimal.h:67
int my_decimal2int(uint mask, const my_decimal *d, bool unsigned_flag, longlong *l)
Definition: my_decimal.h:321
static constexpr int DECIMAL_MAX_STR_LENGTH
maximum length of string representation (number of maximum decimal digits + 1 position for sign + 1 p...
Definition: my_decimal.h:74
int my_decimal_string_length(const my_decimal *d)
Definition: my_decimal.h:245
int my_decimal_ceiling(uint mask, const my_decimal *from, my_decimal *to)
Definition: my_decimal.h:309
static constexpr int DECIMAL_MAX_POSSIBLE_PRECISION
the number of digits that my_decimal can possibly contain
Definition: my_decimal.h:59
int my_decimal_mul(uint mask, my_decimal *res, const my_decimal *a, const my_decimal *b)
Definition: my_decimal.h:382
int str2my_decimal(uint mask, const char *str, my_decimal *d, const char **end)
Definition: my_decimal.h:340
const char * dbug_decimal_as_string(char *buff, const my_decimal *val)
Definition: my_decimal.cc:371
uint32 my_decimal_precision_to_length_no_truncation(uint precision, uint8 scale, bool unsigned_flag)
Definition: my_decimal.h:219
my_decimal decimal_zero
Definition: mysqld.cc:1507
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
uint8_t uint8
Definition: my_inttypes.h:62
unsigned char uchar
Definition: my_inttypes.h:51
long long int longlong
Definition: my_inttypes.h:54
uint32_t uint32
Definition: my_inttypes.h:66
Some common macros.
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1063
Definition: buf0block_hint.cc:29
const std::string charset("charset")
Definition: commit_order_queue.h:33
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:75
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:191
struct result result
Definition: result.h:33
static void swap(String &a, String &b) noexcept
Definition: sql_string.h:611
Definition: m_ctype.h:382
Definition: mysql_time.h:81
intg is the number of decimal digits (NOT number of decimal_digit_t's !) before the point frac is the...
Definition: decimal.h:51
int frac
Definition: decimal.h:52
int intg
Definition: decimal.h:52
bool sign
Definition: decimal.h:53
int len
Definition: decimal.h:52
Replacement of system's struct timeval to ensure we can carry 64 bit values even on a platform which ...
Definition: my_time_t.h:44
Definition: result.h:29
unsigned int uint
Definition: uca-dump.cc:29