Branch data Line data Source code
1 : : /*
2 : : * cash.c
3 : : * Written by D'Arcy J.M. Cain
4 : : * darcy@druid.net
5 : : * http://www.druid.net/darcy/
6 : : *
7 : : * Functions to allow input and output of money normally but store
8 : : * and handle it as 64 bit ints
9 : : *
10 : : * A slightly modified version of this file and a discussion of the
11 : : * workings can be found in the book "Software Solutions in C" by
12 : : * Dale Schumacher, Academic Press, ISBN: 0-12-632360-7 except that
13 : : * this version handles 64 bit numbers and so can hold values up to
14 : : * $92,233,720,368,547,758.07.
15 : : *
16 : : * src/backend/utils/adt/cash.c
17 : : */
18 : :
19 : : #include "postgres.h"
20 : :
21 : : #include <limits.h>
22 : : #include <ctype.h>
23 : : #include <math.h>
24 : :
25 : : #include "common/int.h"
26 : : #include "libpq/pqformat.h"
27 : : #include "utils/builtins.h"
28 : : #include "utils/cash.h"
29 : : #include "utils/float.h"
30 : : #include "utils/numeric.h"
31 : : #include "utils/pg_locale.h"
32 : :
33 : :
34 : : /*************************************************************************
35 : : * Private routines
36 : : ************************************************************************/
37 : :
38 : : static void
39 : 4 : append_num_word(StringInfo buf, Cash value)
40 : : {
41 : : static const char *const small[] = {
42 : : "zero", "one", "two", "three", "four", "five", "six", "seven",
43 : : "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
44 : : "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty",
45 : : "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"
46 : : };
47 : 4 : const char *const *big = small + 18;
48 : 4 : int tu = value % 100;
49 : :
50 : : /* deal with the simple cases first */
51 [ + + ]: 4 : if (value <= 20)
52 : : {
53 : 1 : appendStringInfoString(buf, small[value]);
54 : 1 : return;
55 : : }
56 : :
57 : : /* is it an even multiple of 100? */
58 [ + - ]: 3 : if (!tu)
59 : : {
60 : 0 : appendStringInfo(buf, "%s hundred", small[value / 100]);
61 : 0 : return;
62 : : }
63 : :
64 : : /* more than 99? */
65 [ + + ]: 3 : if (value > 99)
66 : : {
67 : : /* is it an even multiple of 10 other than 10? */
68 [ - + # # ]: 2 : if (value % 10 == 0 && tu > 10)
69 : 0 : appendStringInfo(buf, "%s hundred %s",
70 : 0 : small[value / 100], big[tu / 10]);
71 [ - + ]: 2 : else if (tu < 20)
72 : 0 : appendStringInfo(buf, "%s hundred and %s",
73 : 0 : small[value / 100], small[tu]);
74 : : else
75 : 4 : appendStringInfo(buf, "%s hundred %s %s",
76 : 2 : small[value / 100], big[tu / 10], small[tu % 10]);
77 : 2 : }
78 : : else
79 : : {
80 : : /* is it an even multiple of 10 other than 10? */
81 [ - + # # ]: 1 : if (value % 10 == 0 && tu > 10)
82 : 0 : appendStringInfoString(buf, big[tu / 10]);
83 [ - + ]: 1 : else if (tu < 20)
84 : 0 : appendStringInfoString(buf, small[tu]);
85 : : else
86 : 1 : appendStringInfo(buf, "%s %s", big[tu / 10], small[tu % 10]);
87 : : }
88 [ - + ]: 4 : }
89 : :
90 : : static inline Cash
91 : 5 : cash_pl_cash(Cash c1, Cash c2)
92 : : {
93 : 5 : Cash res;
94 : :
95 [ + + ]: 5 : if (unlikely(pg_add_s64_overflow(c1, c2, &res)))
96 [ + - + - ]: 1 : ereport(ERROR,
97 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
98 : : errmsg("money out of range")));
99 : :
100 : 8 : return res;
101 : 4 : }
102 : :
103 : : static inline Cash
104 : 3 : cash_mi_cash(Cash c1, Cash c2)
105 : : {
106 : 3 : Cash res;
107 : :
108 [ + + ]: 3 : if (unlikely(pg_sub_s64_overflow(c1, c2, &res)))
109 [ + - + - ]: 1 : ereport(ERROR,
110 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
111 : : errmsg("money out of range")));
112 : :
113 : 4 : return res;
114 : 2 : }
115 : :
116 : : static inline Cash
117 : 8 : cash_mul_float8(Cash c, float8 f)
118 : : {
119 : 8 : float8 res = rint(float8_mul((float8) c, f));
120 : :
121 [ - + + + : 8 : if (unlikely(isnan(res) || !FLOAT8_FITS_IN_INT64(res)))
+ - + + +
+ ]
122 [ + - + - ]: 4 : ereport(ERROR,
123 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
124 : : errmsg("money out of range")));
125 : :
126 : 36 : return (Cash) res;
127 : 18 : }
128 : :
129 : : static inline Cash
130 : 5 : cash_div_float8(Cash c, float8 f)
131 : : {
132 : 5 : float8 res = rint(float8_div((float8) c, f));
133 : :
134 [ - + + + : 5 : if (unlikely(isnan(res) || !FLOAT8_FITS_IN_INT64(res)))
+ - + + +
+ ]
135 [ + - + - ]: 1 : ereport(ERROR,
136 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
137 : : errmsg("money out of range")));
138 : :
139 : 28 : return (Cash) res;
140 : 14 : }
141 : :
142 : : static inline Cash
143 : 7 : cash_mul_int64(Cash c, int64 i)
144 : : {
145 : 7 : Cash res;
146 : :
147 [ + + ]: 7 : if (unlikely(pg_mul_s64_overflow(c, i, &res)))
148 [ + - + - ]: 1 : ereport(ERROR,
149 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
150 : : errmsg("money out of range")));
151 : :
152 : 12 : return res;
153 : 6 : }
154 : :
155 : : static inline Cash
156 : 10 : cash_div_int64(Cash c, int64 i)
157 : : {
158 [ + + ]: 10 : if (unlikely(i == 0))
159 [ + - + - ]: 1 : ereport(ERROR,
160 : : (errcode(ERRCODE_DIVISION_BY_ZERO),
161 : : errmsg("division by zero")));
162 : :
163 : 9 : return c / i;
164 : : }
165 : :
166 : : /* cash_in()
167 : : * Convert a string to a cash data type.
168 : : * Format is [$]###[,]###[.##]
169 : : * Examples: 123.45 $123.45 $123,456.78
170 : : *
171 : : */
172 : : Datum
173 : 76 : cash_in(PG_FUNCTION_ARGS)
174 : : {
175 : 76 : char *str = PG_GETARG_CSTRING(0);
176 : 76 : Node *escontext = fcinfo->context;
177 : 76 : Cash result;
178 : 76 : Cash value = 0;
179 : 76 : Cash dec = 0;
180 : 76 : Cash sgn = 1;
181 : 76 : bool seen_dot = false;
182 : 76 : const char *s = str;
183 : 76 : int fpoint;
184 : 76 : char dsymbol;
185 : 76 : const char *ssymbol,
186 : : *psymbol,
187 : : *nsymbol,
188 : : *csymbol;
189 : 76 : struct lconv *lconvert = PGLC_localeconv();
190 : :
191 : : /*
192 : : * frac_digits will be CHAR_MAX in some locales, notably C. However, just
193 : : * testing for == CHAR_MAX is risky, because of compilers like gcc that
194 : : * "helpfully" let you alter the platform-standard definition of whether
195 : : * char is signed or not. If we are so unfortunate as to get compiled
196 : : * with a nonstandard -fsigned-char or -funsigned-char switch, then our
197 : : * idea of CHAR_MAX will not agree with libc's. The safest course is not
198 : : * to test for CHAR_MAX at all, but to impose a range check for plausible
199 : : * frac_digits values.
200 : : */
201 : 76 : fpoint = lconvert->frac_digits;
202 [ + - + - ]: 76 : if (fpoint < 0 || fpoint > 10)
203 : 76 : fpoint = 2; /* best guess in this case, I think */
204 : :
205 : : /* we restrict dsymbol to be a single byte, but not the other symbols */
206 [ - + # # ]: 76 : if (*lconvert->mon_decimal_point != '\0' &&
207 : 0 : lconvert->mon_decimal_point[1] == '\0')
208 : 0 : dsymbol = *lconvert->mon_decimal_point;
209 : : else
210 : 76 : dsymbol = '.';
211 [ - + ]: 76 : if (*lconvert->mon_thousands_sep != '\0')
212 : 0 : ssymbol = lconvert->mon_thousands_sep;
213 : : else /* ssymbol should not equal dsymbol */
214 : 76 : ssymbol = (dsymbol != ',') ? "," : ".";
215 [ - + ]: 76 : csymbol = (*lconvert->currency_symbol != '\0') ? lconvert->currency_symbol : "$";
216 [ - + ]: 76 : psymbol = (*lconvert->positive_sign != '\0') ? lconvert->positive_sign : "+";
217 [ - + ]: 76 : nsymbol = (*lconvert->negative_sign != '\0') ? lconvert->negative_sign : "-";
218 : :
219 : : #ifdef CASHDEBUG
220 : : printf("cashin- precision '%d'; decimal '%c'; thousands '%s'; currency '%s'; positive '%s'; negative '%s'\n",
221 : : fpoint, dsymbol, ssymbol, csymbol, psymbol, nsymbol);
222 : : #endif
223 : :
224 : : /* we need to add all sorts of checking here. For now just */
225 : : /* strip all leading whitespace and any leading currency symbol */
226 [ - + ]: 76 : while (isspace((unsigned char) *s))
227 : 0 : s++;
228 [ + + ]: 76 : if (strncmp(s, csymbol, strlen(csymbol)) == 0)
229 : 20 : s += strlen(csymbol);
230 [ - + ]: 76 : while (isspace((unsigned char) *s))
231 : 0 : s++;
232 : :
233 : : #ifdef CASHDEBUG
234 : : printf("cashin- string is '%s'\n", s);
235 : : #endif
236 : :
237 : : /* a leading minus or paren signifies a negative number */
238 : : /* again, better heuristics needed */
239 : : /* XXX - doesn't properly check for balanced parens - djmc */
240 [ + + ]: 76 : if (strncmp(s, nsymbol, strlen(nsymbol)) == 0)
241 : : {
242 : 12 : sgn = -1;
243 : 12 : s += strlen(nsymbol);
244 : 12 : }
245 [ + + ]: 64 : else if (*s == '(')
246 : : {
247 : 2 : sgn = -1;
248 : 2 : s++;
249 : 2 : }
250 [ + - ]: 62 : else if (strncmp(s, psymbol, strlen(psymbol)) == 0)
251 : 0 : s += strlen(psymbol);
252 : :
253 : : #ifdef CASHDEBUG
254 : : printf("cashin- string is '%s'\n", s);
255 : : #endif
256 : :
257 : : /* allow whitespace and currency symbol after the sign, too */
258 [ - + ]: 76 : while (isspace((unsigned char) *s))
259 : 0 : s++;
260 [ + + ]: 76 : if (strncmp(s, csymbol, strlen(csymbol)) == 0)
261 : 1 : s += strlen(csymbol);
262 [ - + ]: 76 : while (isspace((unsigned char) *s))
263 : 0 : s++;
264 : :
265 : : #ifdef CASHDEBUG
266 : : printf("cashin- string is '%s'\n", s);
267 : : #endif
268 : :
269 : : /*
270 : : * We accumulate the absolute amount in "value" and then apply the sign at
271 : : * the end. (The sign can appear before or after the digits, so it would
272 : : * be more complicated to do otherwise.) Because of the larger range of
273 : : * negative signed integers, we build "value" in the negative and then
274 : : * flip the sign at the end, catching most-negative-number overflow if
275 : : * necessary.
276 : : */
277 : :
278 [ + + ]: 807 : for (; *s; s++)
279 : : {
280 : : /*
281 : : * We look for digits as long as we have found less than the required
282 : : * number of decimal places.
283 : : */
284 [ + + + + : 742 : if (isdigit((unsigned char) *s) && (!seen_dot || dec < fpoint))
+ + ]
285 : : {
286 : 677 : int8 digit = *s - '0';
287 : :
288 [ + + + + ]: 677 : if (pg_mul_s64_overflow(value, 10, &value) ||
289 : 676 : pg_sub_s64_overflow(value, digit, &value))
290 [ - + ]: 2 : ereturn(escontext, (Datum) 0,
291 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
292 : : errmsg("value \"%s\" is out of range for type %s",
293 : : str, "money")));
294 : :
295 [ + + ]: 675 : if (seen_dot)
296 : 103 : dec++;
297 [ - + ]: 677 : }
298 : : /* decimal point? then start counting fractions... */
299 [ + + - + ]: 65 : else if (*s == dsymbol && !seen_dot)
300 : : {
301 : 53 : seen_dot = true;
302 : 53 : }
303 : : /* ignore if "thousands" separator, else we're done */
304 [ + + ]: 12 : else if (strncmp(s, ssymbol, strlen(ssymbol)) == 0)
305 : 1 : s += strlen(ssymbol) - 1;
306 : : else
307 : 11 : break;
308 : 731 : }
309 : :
310 : : /* round off if there's another digit */
311 [ + + + + ]: 76 : if (isdigit((unsigned char) *s) && *s >= '5')
312 : : {
313 : : /* remember we build the value in the negative */
314 [ + + ]: 6 : if (pg_sub_s64_overflow(value, 1, &value))
315 [ + + ]: 2 : ereturn(escontext, (Datum) 0,
316 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
317 : : errmsg("value \"%s\" is out of range for type %s",
318 : : str, "money")));
319 : 4 : }
320 : :
321 : : /* adjust for less than required decimal places */
322 [ + + ]: 114 : for (; dec < fpoint; dec++)
323 : : {
324 [ + + ]: 44 : if (pg_mul_s64_overflow(value, 10, &value))
325 [ - + ]: 4 : ereturn(escontext, (Datum) 0,
326 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
327 : : errmsg("value \"%s\" is out of range for type %s",
328 : : str, "money")));
329 : 40 : }
330 : :
331 : : /*
332 : : * should only be trailing digits followed by whitespace, right paren,
333 : : * trailing sign, and/or trailing currency symbol
334 : : */
335 [ + + ]: 76 : while (isdigit((unsigned char) *s))
336 : 6 : s++;
337 : :
338 [ + + ]: 72 : while (*s)
339 : : {
340 [ + - + + ]: 4 : if (isspace((unsigned char) *s) || *s == ')')
341 : 2 : s++;
342 [ + - ]: 2 : else if (strncmp(s, nsymbol, strlen(nsymbol)) == 0)
343 : : {
344 : 0 : sgn = -1;
345 : 0 : s += strlen(nsymbol);
346 : 0 : }
347 [ + - ]: 2 : else if (strncmp(s, psymbol, strlen(psymbol)) == 0)
348 : 0 : s += strlen(psymbol);
349 [ + - ]: 2 : else if (strncmp(s, csymbol, strlen(csymbol)) == 0)
350 : 0 : s += strlen(csymbol);
351 : : else
352 [ + + ]: 2 : ereturn(escontext, (Datum) 0,
353 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
354 : : errmsg("invalid input syntax for type %s: \"%s\"",
355 : : "money", str)));
356 : : }
357 : :
358 : : /*
359 : : * If the value is supposed to be positive, flip the sign, but check for
360 : : * the most negative number.
361 : : */
362 [ + + ]: 68 : if (sgn > 0)
363 : : {
364 [ + + ]: 58 : if (value == PG_INT64_MIN)
365 [ + + ]: 4 : ereturn(escontext, (Datum) 0,
366 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
367 : : errmsg("value \"%s\" is out of range for type %s",
368 : : str, "money")));
369 : 54 : result = -value;
370 : 54 : }
371 : : else
372 : 10 : result = value;
373 : :
374 : : #ifdef CASHDEBUG
375 : : printf("cashin- result is " INT64_FORMAT "\n", result);
376 : : #endif
377 : :
378 : 64 : PG_RETURN_CASH(result);
379 : 70 : }
380 : :
381 : :
382 : : /* cash_out()
383 : : * Function to convert cash to a dollars and cents representation, using
384 : : * the lc_monetary locale's formatting.
385 : : */
386 : : Datum
387 : 57 : cash_out(PG_FUNCTION_ARGS)
388 : : {
389 : 57 : Cash value = PG_GETARG_CASH(0);
390 : 57 : uint64 uvalue;
391 : 57 : char *result;
392 : 57 : char buf[128];
393 : 57 : char *bufptr;
394 : 57 : int digit_pos;
395 : 57 : int points,
396 : : mon_group;
397 : 57 : char dsymbol;
398 : 57 : const char *ssymbol,
399 : : *csymbol,
400 : : *signsymbol;
401 : 57 : char sign_posn,
402 : : cs_precedes,
403 : : sep_by_space;
404 : 57 : struct lconv *lconvert = PGLC_localeconv();
405 : :
406 : : /* see comments about frac_digits in cash_in() */
407 : 57 : points = lconvert->frac_digits;
408 [ + - + - ]: 57 : if (points < 0 || points > 10)
409 : 57 : points = 2; /* best guess in this case, I think */
410 : :
411 : : /*
412 : : * As with frac_digits, must apply a range check to mon_grouping to avoid
413 : : * being fooled by variant CHAR_MAX values.
414 : : */
415 : 57 : mon_group = *lconvert->mon_grouping;
416 [ - + # # ]: 57 : if (mon_group <= 0 || mon_group > 6)
417 : 57 : mon_group = 3;
418 : :
419 : : /* we restrict dsymbol to be a single byte, but not the other symbols */
420 [ - + # # ]: 57 : if (*lconvert->mon_decimal_point != '\0' &&
421 : 0 : lconvert->mon_decimal_point[1] == '\0')
422 : 0 : dsymbol = *lconvert->mon_decimal_point;
423 : : else
424 : 57 : dsymbol = '.';
425 [ - + ]: 57 : if (*lconvert->mon_thousands_sep != '\0')
426 : 0 : ssymbol = lconvert->mon_thousands_sep;
427 : : else /* ssymbol should not equal dsymbol */
428 : 57 : ssymbol = (dsymbol != ',') ? "," : ".";
429 [ - + ]: 57 : csymbol = (*lconvert->currency_symbol != '\0') ? lconvert->currency_symbol : "$";
430 : :
431 [ + + ]: 57 : if (value < 0)
432 : : {
433 : : /* set up formatting data */
434 [ - + ]: 13 : signsymbol = (*lconvert->negative_sign != '\0') ? lconvert->negative_sign : "-";
435 : 13 : sign_posn = lconvert->n_sign_posn;
436 : 13 : cs_precedes = lconvert->n_cs_precedes;
437 : 13 : sep_by_space = lconvert->n_sep_by_space;
438 : 13 : }
439 : : else
440 : : {
441 : 44 : signsymbol = lconvert->positive_sign;
442 : 44 : sign_posn = lconvert->p_sign_posn;
443 : 44 : cs_precedes = lconvert->p_cs_precedes;
444 : 44 : sep_by_space = lconvert->p_sep_by_space;
445 : : }
446 : :
447 : : /* make the amount positive for digit-reconstruction loop */
448 : 57 : uvalue = pg_abs_s64(value);
449 : :
450 : : /* we build the digits+decimal-point+sep string right-to-left in buf[] */
451 : 57 : bufptr = buf + sizeof(buf) - 1;
452 : 57 : *bufptr = '\0';
453 : :
454 : : /*
455 : : * Generate digits till there are no non-zero digits left and we emitted
456 : : * at least one to the left of the decimal point. digit_pos is the
457 : : * current digit position, with zero as the digit just left of the decimal
458 : : * point, increasing to the right.
459 : : */
460 : 57 : digit_pos = points;
461 : 57 : do
462 : : {
463 [ + - + + ]: 495 : if (points && digit_pos == 0)
464 : : {
465 : : /* insert decimal point, but not if value cannot be fractional */
466 : 57 : *(--bufptr) = dsymbol;
467 : 57 : }
468 [ + + + + ]: 438 : else if (digit_pos < 0 && (digit_pos % mon_group) == 0)
469 : : {
470 : : /* insert thousands sep, but only to left of radix point */
471 : 86 : bufptr -= strlen(ssymbol);
472 : 86 : memcpy(bufptr, ssymbol, strlen(ssymbol));
473 : 86 : }
474 : :
475 : 495 : *(--bufptr) = (uvalue % 10) + '0';
476 : 495 : uvalue = uvalue / 10;
477 : 495 : digit_pos--;
478 [ + + + + ]: 495 : } while (uvalue || digit_pos >= 0);
479 : :
480 : : /*----------
481 : : * Now, attach currency symbol and sign symbol in the correct order.
482 : : *
483 : : * The POSIX spec defines these values controlling this code:
484 : : *
485 : : * p/n_sign_posn:
486 : : * 0 Parentheses enclose the quantity and the currency_symbol.
487 : : * 1 The sign string precedes the quantity and the currency_symbol.
488 : : * 2 The sign string succeeds the quantity and the currency_symbol.
489 : : * 3 The sign string precedes the currency_symbol.
490 : : * 4 The sign string succeeds the currency_symbol.
491 : : *
492 : : * p/n_cs_precedes: 0 means currency symbol after value, else before it.
493 : : *
494 : : * p/n_sep_by_space:
495 : : * 0 No <space> separates the currency symbol and value.
496 : : * 1 If the currency symbol and sign string are adjacent, a <space>
497 : : * separates them from the value; otherwise, a <space> separates
498 : : * the currency symbol from the value.
499 : : * 2 If the currency symbol and sign string are adjacent, a <space>
500 : : * separates them; otherwise, a <space> separates the sign string
501 : : * from the value.
502 : : *----------
503 : : */
504 [ - + - - : 57 : switch (sign_posn)
- - ]
505 : : {
506 : : case 0:
507 [ # # ]: 0 : if (cs_precedes)
508 : 0 : result = psprintf("(%s%s%s)",
509 : 0 : csymbol,
510 : 0 : (sep_by_space == 1) ? " " : "",
511 : 0 : bufptr);
512 : : else
513 : 0 : result = psprintf("(%s%s%s)",
514 : 0 : bufptr,
515 : 0 : (sep_by_space == 1) ? " " : "",
516 : 0 : csymbol);
517 : 0 : break;
518 : 0 : case 1:
519 : : default:
520 [ - + ]: 57 : if (cs_precedes)
521 : 57 : result = psprintf("%s%s%s%s%s",
522 : 57 : signsymbol,
523 : 57 : (sep_by_space == 2) ? " " : "",
524 : 57 : csymbol,
525 : 57 : (sep_by_space == 1) ? " " : "",
526 : 57 : bufptr);
527 : : else
528 : 0 : result = psprintf("%s%s%s%s%s",
529 : 0 : signsymbol,
530 : 0 : (sep_by_space == 2) ? " " : "",
531 : 0 : bufptr,
532 : 0 : (sep_by_space == 1) ? " " : "",
533 : 0 : csymbol);
534 : 57 : break;
535 : : case 2:
536 [ # # ]: 0 : if (cs_precedes)
537 : 0 : result = psprintf("%s%s%s%s%s",
538 : 0 : csymbol,
539 : 0 : (sep_by_space == 1) ? " " : "",
540 : 0 : bufptr,
541 : 0 : (sep_by_space == 2) ? " " : "",
542 : 0 : signsymbol);
543 : : else
544 : 0 : result = psprintf("%s%s%s%s%s",
545 : 0 : bufptr,
546 : 0 : (sep_by_space == 1) ? " " : "",
547 : 0 : csymbol,
548 : 0 : (sep_by_space == 2) ? " " : "",
549 : 0 : signsymbol);
550 : 0 : break;
551 : : case 3:
552 [ # # ]: 0 : if (cs_precedes)
553 : 0 : result = psprintf("%s%s%s%s%s",
554 : 0 : signsymbol,
555 : 0 : (sep_by_space == 2) ? " " : "",
556 : 0 : csymbol,
557 : 0 : (sep_by_space == 1) ? " " : "",
558 : 0 : bufptr);
559 : : else
560 : 0 : result = psprintf("%s%s%s%s%s",
561 : 0 : bufptr,
562 : 0 : (sep_by_space == 1) ? " " : "",
563 : 0 : signsymbol,
564 : 0 : (sep_by_space == 2) ? " " : "",
565 : 0 : csymbol);
566 : 0 : break;
567 : : case 4:
568 [ # # ]: 0 : if (cs_precedes)
569 : 0 : result = psprintf("%s%s%s%s%s",
570 : 0 : csymbol,
571 : 0 : (sep_by_space == 2) ? " " : "",
572 : 0 : signsymbol,
573 : 0 : (sep_by_space == 1) ? " " : "",
574 : 0 : bufptr);
575 : : else
576 : 0 : result = psprintf("%s%s%s%s%s",
577 : 0 : bufptr,
578 : 0 : (sep_by_space == 1) ? " " : "",
579 : 0 : csymbol,
580 : 0 : (sep_by_space == 2) ? " " : "",
581 : 0 : signsymbol);
582 : 0 : break;
583 : : }
584 : :
585 : 114 : PG_RETURN_CSTRING(result);
586 : 57 : }
587 : :
588 : : /*
589 : : * cash_recv - converts external binary format to cash
590 : : */
591 : : Datum
592 : 0 : cash_recv(PG_FUNCTION_ARGS)
593 : : {
594 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
595 : :
596 : 0 : PG_RETURN_CASH((Cash) pq_getmsgint64(buf));
597 : 0 : }
598 : :
599 : : /*
600 : : * cash_send - converts cash to binary format
601 : : */
602 : : Datum
603 : 0 : cash_send(PG_FUNCTION_ARGS)
604 : : {
605 : 0 : Cash arg1 = PG_GETARG_CASH(0);
606 : 0 : StringInfoData buf;
607 : :
608 : 0 : pq_begintypsend(&buf);
609 : 0 : pq_sendint64(&buf, arg1);
610 : 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
611 : 0 : }
612 : :
613 : : /*
614 : : * Comparison functions
615 : : */
616 : :
617 : : Datum
618 : 2 : cash_eq(PG_FUNCTION_ARGS)
619 : : {
620 : 2 : Cash c1 = PG_GETARG_CASH(0);
621 : 2 : Cash c2 = PG_GETARG_CASH(1);
622 : :
623 : 4 : PG_RETURN_BOOL(c1 == c2);
624 : 2 : }
625 : :
626 : : Datum
627 : 2 : cash_ne(PG_FUNCTION_ARGS)
628 : : {
629 : 2 : Cash c1 = PG_GETARG_CASH(0);
630 : 2 : Cash c2 = PG_GETARG_CASH(1);
631 : :
632 : 4 : PG_RETURN_BOOL(c1 != c2);
633 : 2 : }
634 : :
635 : : Datum
636 : 2 : cash_lt(PG_FUNCTION_ARGS)
637 : : {
638 : 2 : Cash c1 = PG_GETARG_CASH(0);
639 : 2 : Cash c2 = PG_GETARG_CASH(1);
640 : :
641 : 4 : PG_RETURN_BOOL(c1 < c2);
642 : 2 : }
643 : :
644 : : Datum
645 : 2 : cash_le(PG_FUNCTION_ARGS)
646 : : {
647 : 2 : Cash c1 = PG_GETARG_CASH(0);
648 : 2 : Cash c2 = PG_GETARG_CASH(1);
649 : :
650 : 4 : PG_RETURN_BOOL(c1 <= c2);
651 : 2 : }
652 : :
653 : : Datum
654 : 2 : cash_gt(PG_FUNCTION_ARGS)
655 : : {
656 : 2 : Cash c1 = PG_GETARG_CASH(0);
657 : 2 : Cash c2 = PG_GETARG_CASH(1);
658 : :
659 : 4 : PG_RETURN_BOOL(c1 > c2);
660 : 2 : }
661 : :
662 : : Datum
663 : 2 : cash_ge(PG_FUNCTION_ARGS)
664 : : {
665 : 2 : Cash c1 = PG_GETARG_CASH(0);
666 : 2 : Cash c2 = PG_GETARG_CASH(1);
667 : :
668 : 4 : PG_RETURN_BOOL(c1 >= c2);
669 : 2 : }
670 : :
671 : : Datum
672 : 4 : cash_cmp(PG_FUNCTION_ARGS)
673 : : {
674 : 4 : Cash c1 = PG_GETARG_CASH(0);
675 : 4 : Cash c2 = PG_GETARG_CASH(1);
676 : :
677 [ - + ]: 4 : if (c1 > c2)
678 : 0 : PG_RETURN_INT32(1);
679 [ - + ]: 4 : else if (c1 == c2)
680 : 0 : PG_RETURN_INT32(0);
681 : : else
682 : 4 : PG_RETURN_INT32(-1);
683 : 4 : }
684 : :
685 : :
686 : : /* cash_pl()
687 : : * Add two cash values.
688 : : */
689 : : Datum
690 : 5 : cash_pl(PG_FUNCTION_ARGS)
691 : : {
692 : 5 : Cash c1 = PG_GETARG_CASH(0);
693 : 5 : Cash c2 = PG_GETARG_CASH(1);
694 : :
695 : 10 : PG_RETURN_CASH(cash_pl_cash(c1, c2));
696 : 5 : }
697 : :
698 : :
699 : : /* cash_mi()
700 : : * Subtract two cash values.
701 : : */
702 : : Datum
703 : 3 : cash_mi(PG_FUNCTION_ARGS)
704 : : {
705 : 3 : Cash c1 = PG_GETARG_CASH(0);
706 : 3 : Cash c2 = PG_GETARG_CASH(1);
707 : :
708 : 6 : PG_RETURN_CASH(cash_mi_cash(c1, c2));
709 : 3 : }
710 : :
711 : :
712 : : /* cash_div_cash()
713 : : * Divide cash by cash, returning float8.
714 : : */
715 : : Datum
716 : 1 : cash_div_cash(PG_FUNCTION_ARGS)
717 : : {
718 : 1 : Cash dividend = PG_GETARG_CASH(0);
719 : 1 : Cash divisor = PG_GETARG_CASH(1);
720 : 1 : float8 quotient;
721 : :
722 [ + - ]: 1 : if (divisor == 0)
723 [ # # # # ]: 0 : ereport(ERROR,
724 : : (errcode(ERRCODE_DIVISION_BY_ZERO),
725 : : errmsg("division by zero")));
726 : :
727 : 1 : quotient = (float8) dividend / (float8) divisor;
728 : 2 : PG_RETURN_FLOAT8(quotient);
729 : 1 : }
730 : :
731 : :
732 : : /* cash_mul_flt8()
733 : : * Multiply cash by float8.
734 : : */
735 : : Datum
736 : 4 : cash_mul_flt8(PG_FUNCTION_ARGS)
737 : : {
738 : 4 : Cash c = PG_GETARG_CASH(0);
739 : 4 : float8 f = PG_GETARG_FLOAT8(1);
740 : :
741 : 8 : PG_RETURN_CASH(cash_mul_float8(c, f));
742 : 4 : }
743 : :
744 : :
745 : : /* flt8_mul_cash()
746 : : * Multiply float8 by cash.
747 : : */
748 : : Datum
749 : 1 : flt8_mul_cash(PG_FUNCTION_ARGS)
750 : : {
751 : 1 : float8 f = PG_GETARG_FLOAT8(0);
752 : 1 : Cash c = PG_GETARG_CASH(1);
753 : :
754 : 2 : PG_RETURN_CASH(cash_mul_float8(c, f));
755 : 1 : }
756 : :
757 : :
758 : : /* cash_div_flt8()
759 : : * Divide cash by float8.
760 : : */
761 : : Datum
762 : 2 : cash_div_flt8(PG_FUNCTION_ARGS)
763 : : {
764 : 2 : Cash c = PG_GETARG_CASH(0);
765 : 2 : float8 f = PG_GETARG_FLOAT8(1);
766 : :
767 : 4 : PG_RETURN_CASH(cash_div_float8(c, f));
768 : 2 : }
769 : :
770 : :
771 : : /* cash_mul_flt4()
772 : : * Multiply cash by float4.
773 : : */
774 : : Datum
775 : 2 : cash_mul_flt4(PG_FUNCTION_ARGS)
776 : : {
777 : 2 : Cash c = PG_GETARG_CASH(0);
778 : 2 : float4 f = PG_GETARG_FLOAT4(1);
779 : :
780 : 4 : PG_RETURN_CASH(cash_mul_float8(c, (float8) f));
781 : 2 : }
782 : :
783 : :
784 : : /* flt4_mul_cash()
785 : : * Multiply float4 by cash.
786 : : */
787 : : Datum
788 : 1 : flt4_mul_cash(PG_FUNCTION_ARGS)
789 : : {
790 : 1 : float4 f = PG_GETARG_FLOAT4(0);
791 : 1 : Cash c = PG_GETARG_CASH(1);
792 : :
793 : 2 : PG_RETURN_CASH(cash_mul_float8(c, (float8) f));
794 : 1 : }
795 : :
796 : :
797 : : /* cash_div_flt4()
798 : : * Divide cash by float4.
799 : : *
800 : : */
801 : : Datum
802 : 3 : cash_div_flt4(PG_FUNCTION_ARGS)
803 : : {
804 : 3 : Cash c = PG_GETARG_CASH(0);
805 : 3 : float4 f = PG_GETARG_FLOAT4(1);
806 : :
807 : 6 : PG_RETURN_CASH(cash_div_float8(c, (float8) f));
808 : 3 : }
809 : :
810 : :
811 : : /* cash_mul_int8()
812 : : * Multiply cash by int8.
813 : : */
814 : : Datum
815 : 1 : cash_mul_int8(PG_FUNCTION_ARGS)
816 : : {
817 : 1 : Cash c = PG_GETARG_CASH(0);
818 : 1 : int64 i = PG_GETARG_INT64(1);
819 : :
820 : 2 : PG_RETURN_CASH(cash_mul_int64(c, i));
821 : 1 : }
822 : :
823 : :
824 : : /* int8_mul_cash()
825 : : * Multiply int8 by cash.
826 : : */
827 : : Datum
828 : 1 : int8_mul_cash(PG_FUNCTION_ARGS)
829 : : {
830 : 1 : int64 i = PG_GETARG_INT64(0);
831 : 1 : Cash c = PG_GETARG_CASH(1);
832 : :
833 : 2 : PG_RETURN_CASH(cash_mul_int64(c, i));
834 : 1 : }
835 : :
836 : : /* cash_div_int8()
837 : : * Divide cash by 8-byte integer.
838 : : */
839 : : Datum
840 : 3 : cash_div_int8(PG_FUNCTION_ARGS)
841 : : {
842 : 3 : Cash c = PG_GETARG_CASH(0);
843 : 3 : int64 i = PG_GETARG_INT64(1);
844 : :
845 : 6 : PG_RETURN_CASH(cash_div_int64(c, i));
846 : 3 : }
847 : :
848 : :
849 : : /* cash_mul_int4()
850 : : * Multiply cash by int4.
851 : : */
852 : : Datum
853 : 2 : cash_mul_int4(PG_FUNCTION_ARGS)
854 : : {
855 : 2 : Cash c = PG_GETARG_CASH(0);
856 : 2 : int32 i = PG_GETARG_INT32(1);
857 : :
858 : 4 : PG_RETURN_CASH(cash_mul_int64(c, (int64) i));
859 : 2 : }
860 : :
861 : :
862 : : /* int4_mul_cash()
863 : : * Multiply int4 by cash.
864 : : */
865 : : Datum
866 : 1 : int4_mul_cash(PG_FUNCTION_ARGS)
867 : : {
868 : 1 : int32 i = PG_GETARG_INT32(0);
869 : 1 : Cash c = PG_GETARG_CASH(1);
870 : :
871 : 2 : PG_RETURN_CASH(cash_mul_int64(c, (int64) i));
872 : 1 : }
873 : :
874 : :
875 : : /* cash_div_int4()
876 : : * Divide cash by 4-byte integer.
877 : : *
878 : : */
879 : : Datum
880 : 3 : cash_div_int4(PG_FUNCTION_ARGS)
881 : : {
882 : 3 : Cash c = PG_GETARG_CASH(0);
883 : 3 : int32 i = PG_GETARG_INT32(1);
884 : :
885 : 6 : PG_RETURN_CASH(cash_div_int64(c, (int64) i));
886 : 3 : }
887 : :
888 : :
889 : : /* cash_mul_int2()
890 : : * Multiply cash by int2.
891 : : */
892 : : Datum
893 : 1 : cash_mul_int2(PG_FUNCTION_ARGS)
894 : : {
895 : 1 : Cash c = PG_GETARG_CASH(0);
896 : 1 : int16 s = PG_GETARG_INT16(1);
897 : :
898 : 2 : PG_RETURN_CASH(cash_mul_int64(c, (int64) s));
899 : 1 : }
900 : :
901 : : /* int2_mul_cash()
902 : : * Multiply int2 by cash.
903 : : */
904 : : Datum
905 : 1 : int2_mul_cash(PG_FUNCTION_ARGS)
906 : : {
907 : 1 : int16 s = PG_GETARG_INT16(0);
908 : 1 : Cash c = PG_GETARG_CASH(1);
909 : :
910 : 2 : PG_RETURN_CASH(cash_mul_int64(c, (int64) s));
911 : 1 : }
912 : :
913 : : /* cash_div_int2()
914 : : * Divide cash by int2.
915 : : *
916 : : */
917 : : Datum
918 : 4 : cash_div_int2(PG_FUNCTION_ARGS)
919 : : {
920 : 4 : Cash c = PG_GETARG_CASH(0);
921 : 4 : int16 s = PG_GETARG_INT16(1);
922 : :
923 : 8 : PG_RETURN_CASH(cash_div_int64(c, (int64) s));
924 : 4 : }
925 : :
926 : : /* cashlarger()
927 : : * Return larger of two cash values.
928 : : */
929 : : Datum
930 : 1 : cashlarger(PG_FUNCTION_ARGS)
931 : : {
932 : 1 : Cash c1 = PG_GETARG_CASH(0);
933 : 1 : Cash c2 = PG_GETARG_CASH(1);
934 : 1 : Cash result;
935 : :
936 [ - + ]: 1 : result = (c1 > c2) ? c1 : c2;
937 : :
938 : 2 : PG_RETURN_CASH(result);
939 : 1 : }
940 : :
941 : : /* cashsmaller()
942 : : * Return smaller of two cash values.
943 : : */
944 : : Datum
945 : 1 : cashsmaller(PG_FUNCTION_ARGS)
946 : : {
947 : 1 : Cash c1 = PG_GETARG_CASH(0);
948 : 1 : Cash c2 = PG_GETARG_CASH(1);
949 : 1 : Cash result;
950 : :
951 [ + - ]: 1 : result = (c1 < c2) ? c1 : c2;
952 : :
953 : 2 : PG_RETURN_CASH(result);
954 : 1 : }
955 : :
956 : : /* cash_words()
957 : : * This converts an int4 as well but to a representation using words
958 : : * Obviously way North American centric - sorry
959 : : */
960 : : Datum
961 : 2 : cash_words(PG_FUNCTION_ARGS)
962 : : {
963 : 2 : Cash value = PG_GETARG_CASH(0);
964 : 2 : uint64 val;
965 : 2 : StringInfoData buf;
966 : 2 : text *res;
967 : 2 : Cash dollars;
968 : 2 : Cash m0;
969 : 2 : Cash m1;
970 : 2 : Cash m2;
971 : 2 : Cash m3;
972 : 2 : Cash m4;
973 : 2 : Cash m5;
974 : 2 : Cash m6;
975 : :
976 : 2 : initStringInfo(&buf);
977 : :
978 : : /* work with positive numbers */
979 [ + - ]: 2 : if (value < 0)
980 : : {
981 : 0 : value = -value;
982 : 0 : appendStringInfoString(&buf, "minus ");
983 : 0 : }
984 : :
985 : : /* Now treat as unsigned, to avoid trouble at INT_MIN */
986 : 2 : val = (uint64) value;
987 : :
988 : 2 : dollars = val / INT64CONST(100);
989 : 2 : m0 = val % INT64CONST(100); /* cents */
990 : 2 : m1 = (val / INT64CONST(100)) % 1000; /* hundreds */
991 : 2 : m2 = (val / INT64CONST(100000)) % 1000; /* thousands */
992 : 2 : m3 = (val / INT64CONST(100000000)) % 1000; /* millions */
993 : 2 : m4 = (val / INT64CONST(100000000000)) % 1000; /* billions */
994 : 2 : m5 = (val / INT64CONST(100000000000000)) % 1000; /* trillions */
995 : 2 : m6 = (val / INT64CONST(100000000000000000)) % 1000; /* quadrillions */
996 : :
997 [ + - ]: 2 : if (m6)
998 : : {
999 : 0 : append_num_word(&buf, m6);
1000 : 0 : appendStringInfoString(&buf, " quadrillion ");
1001 : 0 : }
1002 : :
1003 [ + - ]: 2 : if (m5)
1004 : : {
1005 : 0 : append_num_word(&buf, m5);
1006 : 0 : appendStringInfoString(&buf, " trillion ");
1007 : 0 : }
1008 : :
1009 [ + - ]: 2 : if (m4)
1010 : : {
1011 : 0 : append_num_word(&buf, m4);
1012 : 0 : appendStringInfoString(&buf, " billion ");
1013 : 0 : }
1014 : :
1015 [ + - ]: 2 : if (m3)
1016 : : {
1017 : 0 : append_num_word(&buf, m3);
1018 : 0 : appendStringInfoString(&buf, " million ");
1019 : 0 : }
1020 : :
1021 [ + - ]: 2 : if (m2)
1022 : : {
1023 : 0 : append_num_word(&buf, m2);
1024 : 0 : appendStringInfoString(&buf, " thousand ");
1025 : 0 : }
1026 : :
1027 [ - + ]: 2 : if (m1)
1028 : 2 : append_num_word(&buf, m1);
1029 : :
1030 [ + - ]: 2 : if (dollars == 0)
1031 : 0 : appendStringInfoString(&buf, "zero");
1032 : :
1033 : 2 : appendStringInfoString(&buf, dollars == 1 ? " dollar and " : " dollars and ");
1034 : 2 : append_num_word(&buf, m0);
1035 : 2 : appendStringInfoString(&buf, m0 == 1 ? " cent" : " cents");
1036 : :
1037 : : /* capitalize output */
1038 : 2 : buf.data[0] = pg_ascii_toupper((unsigned char) buf.data[0]);
1039 : :
1040 : : /* return as text datum */
1041 : 2 : res = cstring_to_text_with_len(buf.data, buf.len);
1042 : 2 : pfree(buf.data);
1043 : 4 : PG_RETURN_TEXT_P(res);
1044 : 2 : }
1045 : :
1046 : :
1047 : : /* cash_numeric()
1048 : : * Convert cash to numeric.
1049 : : */
1050 : : Datum
1051 : 4 : cash_numeric(PG_FUNCTION_ARGS)
1052 : : {
1053 : 4 : Cash money = PG_GETARG_CASH(0);
1054 : 4 : Datum result;
1055 : 4 : int fpoint;
1056 : 4 : struct lconv *lconvert = PGLC_localeconv();
1057 : :
1058 : : /* see comments about frac_digits in cash_in() */
1059 : 4 : fpoint = lconvert->frac_digits;
1060 [ + - + - ]: 4 : if (fpoint < 0 || fpoint > 10)
1061 : 4 : fpoint = 2;
1062 : :
1063 : : /* convert the integral money value to numeric */
1064 : 4 : result = NumericGetDatum(int64_to_numeric(money));
1065 : :
1066 : : /* scale appropriately, if needed */
1067 [ + - ]: 4 : if (fpoint > 0)
1068 : : {
1069 : 4 : int64 scale;
1070 : 4 : int i;
1071 : 4 : Datum numeric_scale;
1072 : 4 : Datum quotient;
1073 : :
1074 : : /* compute required scale factor */
1075 : 4 : scale = 1;
1076 [ + + ]: 12 : for (i = 0; i < fpoint; i++)
1077 : 8 : scale *= 10;
1078 : 4 : numeric_scale = NumericGetDatum(int64_to_numeric(scale));
1079 : :
1080 : : /*
1081 : : * Given integral inputs approaching INT64_MAX, select_div_scale()
1082 : : * might choose a result scale of zero, causing loss of fractional
1083 : : * digits in the quotient. We can ensure an exact result by setting
1084 : : * the dscale of either input to be at least as large as the desired
1085 : : * result scale. numeric_round() will do that for us.
1086 : : */
1087 : 4 : numeric_scale = DirectFunctionCall2(numeric_round,
1088 : : numeric_scale,
1089 : : Int32GetDatum(fpoint));
1090 : :
1091 : : /* Now we can safely divide ... */
1092 : 4 : quotient = DirectFunctionCall2(numeric_div, result, numeric_scale);
1093 : :
1094 : : /* ... and forcibly round to exactly the intended number of digits */
1095 : 4 : result = DirectFunctionCall2(numeric_round,
1096 : : quotient,
1097 : : Int32GetDatum(fpoint));
1098 : 4 : }
1099 : :
1100 : 8 : PG_RETURN_DATUM(result);
1101 : 4 : }
1102 : :
1103 : : /* numeric_cash()
1104 : : * Convert numeric to cash.
1105 : : */
1106 : : Datum
1107 : 2 : numeric_cash(PG_FUNCTION_ARGS)
1108 : : {
1109 : 2 : Datum amount = PG_GETARG_DATUM(0);
1110 : 2 : Cash result;
1111 : 2 : int fpoint;
1112 : 2 : int64 scale;
1113 : 2 : int i;
1114 : 2 : Datum numeric_scale;
1115 : 2 : struct lconv *lconvert = PGLC_localeconv();
1116 : :
1117 : : /* see comments about frac_digits in cash_in() */
1118 : 2 : fpoint = lconvert->frac_digits;
1119 [ + - + - ]: 2 : if (fpoint < 0 || fpoint > 10)
1120 : 2 : fpoint = 2;
1121 : :
1122 : : /* compute required scale factor */
1123 : 2 : scale = 1;
1124 [ + + ]: 6 : for (i = 0; i < fpoint; i++)
1125 : 4 : scale *= 10;
1126 : :
1127 : : /* multiply the input amount by scale factor */
1128 : 2 : numeric_scale = NumericGetDatum(int64_to_numeric(scale));
1129 : 2 : amount = DirectFunctionCall2(numeric_mul, amount, numeric_scale);
1130 : :
1131 : : /* note that numeric_int8 will round to nearest integer for us */
1132 : 2 : result = DatumGetInt64(DirectFunctionCall1(numeric_int8, amount));
1133 : :
1134 : 4 : PG_RETURN_CASH(result);
1135 : 2 : }
1136 : :
1137 : : /* int4_cash()
1138 : : * Convert int4 (int) to cash
1139 : : */
1140 : : Datum
1141 : 7 : int4_cash(PG_FUNCTION_ARGS)
1142 : : {
1143 : 7 : int32 amount = PG_GETARG_INT32(0);
1144 : 7 : Cash result;
1145 : 7 : int fpoint;
1146 : 7 : int64 scale;
1147 : 7 : int i;
1148 : 7 : struct lconv *lconvert = PGLC_localeconv();
1149 : :
1150 : : /* see comments about frac_digits in cash_in() */
1151 : 7 : fpoint = lconvert->frac_digits;
1152 [ + - + - ]: 7 : if (fpoint < 0 || fpoint > 10)
1153 : 7 : fpoint = 2;
1154 : :
1155 : : /* compute required scale factor */
1156 : 7 : scale = 1;
1157 [ + + ]: 21 : for (i = 0; i < fpoint; i++)
1158 : 14 : scale *= 10;
1159 : :
1160 : : /* compute amount * scale, checking for overflow */
1161 : 7 : result = DatumGetInt64(DirectFunctionCall2(int8mul, Int64GetDatum(amount),
1162 : : Int64GetDatum(scale)));
1163 : :
1164 : 14 : PG_RETURN_CASH(result);
1165 : 7 : }
1166 : :
1167 : : /* int8_cash()
1168 : : * Convert int8 (bigint) to cash
1169 : : */
1170 : : Datum
1171 : 4 : int8_cash(PG_FUNCTION_ARGS)
1172 : : {
1173 : 4 : int64 amount = PG_GETARG_INT64(0);
1174 : 4 : Cash result;
1175 : 4 : int fpoint;
1176 : 4 : int64 scale;
1177 : 4 : int i;
1178 : 4 : struct lconv *lconvert = PGLC_localeconv();
1179 : :
1180 : : /* see comments about frac_digits in cash_in() */
1181 : 4 : fpoint = lconvert->frac_digits;
1182 [ + - + - ]: 4 : if (fpoint < 0 || fpoint > 10)
1183 : 4 : fpoint = 2;
1184 : :
1185 : : /* compute required scale factor */
1186 : 4 : scale = 1;
1187 [ + + ]: 12 : for (i = 0; i < fpoint; i++)
1188 : 8 : scale *= 10;
1189 : :
1190 : : /* compute amount * scale, checking for overflow */
1191 : 4 : result = DatumGetInt64(DirectFunctionCall2(int8mul, Int64GetDatum(amount),
1192 : : Int64GetDatum(scale)));
1193 : :
1194 : 8 : PG_RETURN_CASH(result);
1195 : 4 : }
|
