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