Debian Codegraph @

src/backend/utils/adt/oracle_compat.c

raw
1 /*-------------------------------------------------------------------------
2 * oracle_compat.c
3 * Oracle compatible functions.
4 *
5 * Copyright (c) 1996-2025, PostgreSQL Global Development Group
6 *
7 * Author: Edmund Mergl <[email protected]>
8 * Multibyte enhancement: Tatsuo Ishii <[email protected]>
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/utils/adt/oracle_compat.c
13 *
14 *-------------------------------------------------------------------------
15 */
16 #include "postgres.h"
17
18 #include "common/int.h"
19 #include "mb/pg_wchar.h"
20 #include "miscadmin.h"
21 #include "utils/builtins.h"
22 #include "utils/formatting.h"
23 #include "utils/memutils.h"
24 #include "varatt.h"
25
26
27 static text *dotrim(const char *string, int stringlen,
28 const char *set, int setlen,
29 bool doltrim, bool dortrim);
30 static bytea *dobyteatrim(bytea *string, bytea *set,
31 bool doltrim, bool dortrim);
32
33
34 /********************************************************************
35 *
36 * lower
37 *
38 * Syntax:
39 *
40 * text lower(text string)
41 *
42 * Purpose:
43 *
44 * Returns string, with all letters forced to lowercase.
45 *
46 ********************************************************************/
47
48 Datum
49 lower(PG_FUNCTION_ARGS)
50 {
51 text *in_string = PG_GETARG_TEXT_PP(0);
52 char *out_string;
53 text *result;
54
55 out_string = str_tolower(VARDATA_ANY(in_string),
56 VARSIZE_ANY_EXHDR(in_string),
57 PG_GET_COLLATION());
58 result = cstring_to_text(out_string);
59 pfree(out_string);
60
61 PG_RETURN_TEXT_P(result);
62 }
63
64
65 /********************************************************************
66 *
67 * upper
68 *
69 * Syntax:
70 *
71 * text upper(text string)
72 *
73 * Purpose:
74 *
75 * Returns string, with all letters forced to uppercase.
76 *
77 ********************************************************************/
78
79 Datum
80 upper(PG_FUNCTION_ARGS)
81 {
82 text *in_string = PG_GETARG_TEXT_PP(0);
83 char *out_string;
84 text *result;
85
86 out_string = str_toupper(VARDATA_ANY(in_string),
87 VARSIZE_ANY_EXHDR(in_string),
88 PG_GET_COLLATION());
89 result = cstring_to_text(out_string);
90 pfree(out_string);
91
92 PG_RETURN_TEXT_P(result);
93 }
94
95
96 /********************************************************************
97 *
98 * initcap
99 *
100 * Syntax:
101 *
102 * text initcap(text string)
103 *
104 * Purpose:
105 *
106 * Returns string, with first letter of each word in uppercase, all
107 * other letters in lowercase. A word is defined as a sequence of
108 * alphanumeric characters, delimited by non-alphanumeric
109 * characters.
110 *
111 ********************************************************************/
112
113 Datum
114 initcap(PG_FUNCTION_ARGS)
115 {
116 text *in_string = PG_GETARG_TEXT_PP(0);
117 char *out_string;
118 text *result;
119
120 out_string = str_initcap(VARDATA_ANY(in_string),
121 VARSIZE_ANY_EXHDR(in_string),
122 PG_GET_COLLATION());
123 result = cstring_to_text(out_string);
124 pfree(out_string);
125
126 PG_RETURN_TEXT_P(result);
127 }
128
129 Datum
130 casefold(PG_FUNCTION_ARGS)
131 {
132 text *in_string = PG_GETARG_TEXT_PP(0);
133 char *out_string;
134 text *result;
135
136 out_string = str_casefold(VARDATA_ANY(in_string),
137 VARSIZE_ANY_EXHDR(in_string),
138 PG_GET_COLLATION());
139 result = cstring_to_text(out_string);
140 pfree(out_string);
141
142 PG_RETURN_TEXT_P(result);
143 }
144
145
146 /********************************************************************
147 *
148 * lpad
149 *
150 * Syntax:
151 *
152 * text lpad(text string1, int4 len, text string2)
153 *
154 * Purpose:
155 *
156 * Returns string1, left-padded to length len with the sequence of
157 * characters in string2. If len is less than the length of string1,
158 * instead truncate (on the right) to len.
159 *
160 ********************************************************************/
161
162 Datum
163 lpad(PG_FUNCTION_ARGS)
164 {
165 text *string1 = PG_GETARG_TEXT_PP(0);
166 int32 len = PG_GETARG_INT32(1);
167 text *string2 = PG_GETARG_TEXT_PP(2);
168 text *ret;
169 char *ptr1,
170 *ptr2,
171 *ptr2start,
172 *ptr_ret;
173 const char *ptr2end;
174 int m,
175 s1len,
176 s2len;
177 int bytelen;
178
179 /* Negative len is silently taken as zero */
180 if (len < 0)
181 len = 0;
182
183 s1len = VARSIZE_ANY_EXHDR(string1);
184 if (s1len < 0)
185 s1len = 0; /* shouldn't happen */
186
187 s2len = VARSIZE_ANY_EXHDR(string2);
188 if (s2len < 0)
189 s2len = 0; /* shouldn't happen */
190
191 s1len = pg_mbstrlen_with_len(VARDATA_ANY(string1), s1len);
192
193 if (s1len > len)
194 s1len = len; /* truncate string1 to len chars */
195
196 if (s2len <= 0)
197 len = s1len; /* nothing to pad with, so don't pad */
198
199 /* compute worst-case output length */
200 if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), len,
201 &bytelen)) ||
202 unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
203 unlikely(!AllocSizeIsValid(bytelen)))
204 ereport(ERROR,
205 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
206 errmsg("requested length too large")));
207
208 ret = (text *) palloc(bytelen);
209
210 m = len - s1len;
211
212 ptr2 = ptr2start = VARDATA_ANY(string2);
213 ptr2end = ptr2 + s2len;
214 ptr_ret = VARDATA(ret);
215
216 while (m--)
217 {
218 int mlen = pg_mblen_range(ptr2, ptr2end);
219
220 memcpy(ptr_ret, ptr2, mlen);
221 ptr_ret += mlen;
222 ptr2 += mlen;
223 if (ptr2 == ptr2end) /* wrap around at end of s2 */
224 ptr2 = ptr2start;
225 }
226
227 ptr1 = VARDATA_ANY(string1);
228
229 while (s1len--)
230 {
231 int mlen = pg_mblen_unbounded(ptr1);
232
233 memcpy(ptr_ret, ptr1, mlen);
234 ptr_ret += mlen;
235 ptr1 += mlen;
236 }
237
238 SET_VARSIZE(ret, ptr_ret - (char *) ret);
239
240 PG_RETURN_TEXT_P(ret);
241 }
242
243
244 /********************************************************************
245 *
246 * rpad
247 *
248 * Syntax:
249 *
250 * text rpad(text string1, int4 len, text string2)
251 *
252 * Purpose:
253 *
254 * Returns string1, right-padded to length len with the sequence of
255 * characters in string2. If len is less than the length of string1,
256 * instead truncate (on the right) to len.
257 *
258 ********************************************************************/
259
260 Datum
261 rpad(PG_FUNCTION_ARGS)
262 {
263 text *string1 = PG_GETARG_TEXT_PP(0);
264 int32 len = PG_GETARG_INT32(1);
265 text *string2 = PG_GETARG_TEXT_PP(2);
266 text *ret;
267 char *ptr1,
268 *ptr2,
269 *ptr2start,
270 *ptr_ret;
271 const char *ptr2end;
272 int m,
273 s1len,
274 s2len;
275 int bytelen;
276
277 /* Negative len is silently taken as zero */
278 if (len < 0)
279 len = 0;
280
281 s1len = VARSIZE_ANY_EXHDR(string1);
282 if (s1len < 0)
283 s1len = 0; /* shouldn't happen */
284
285 s2len = VARSIZE_ANY_EXHDR(string2);
286 if (s2len < 0)
287 s2len = 0; /* shouldn't happen */
288
289 s1len = pg_mbstrlen_with_len(VARDATA_ANY(string1), s1len);
290
291 if (s1len > len)
292 s1len = len; /* truncate string1 to len chars */
293
294 if (s2len <= 0)
295 len = s1len; /* nothing to pad with, so don't pad */
296
297 /* compute worst-case output length */
298 if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), len,
299 &bytelen)) ||
300 unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
301 unlikely(!AllocSizeIsValid(bytelen)))
302 ereport(ERROR,
303 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
304 errmsg("requested length too large")));
305
306 ret = (text *) palloc(bytelen);
307
308 m = len - s1len;
309
310 ptr1 = VARDATA_ANY(string1);
311
312 ptr_ret = VARDATA(ret);
313
314 while (s1len--)
315 {
316 int mlen = pg_mblen_unbounded(ptr1);
317
318 memcpy(ptr_ret, ptr1, mlen);
319 ptr_ret += mlen;
320 ptr1 += mlen;
321 }
322
323 ptr2 = ptr2start = VARDATA_ANY(string2);
324 ptr2end = ptr2 + s2len;
325
326 while (m--)
327 {
328 int mlen = pg_mblen_range(ptr2, ptr2end);
329
330 memcpy(ptr_ret, ptr2, mlen);
331 ptr_ret += mlen;
332 ptr2 += mlen;
333 if (ptr2 == ptr2end) /* wrap around at end of s2 */
334 ptr2 = ptr2start;
335 }
336
337 SET_VARSIZE(ret, ptr_ret - (char *) ret);
338
339 PG_RETURN_TEXT_P(ret);
340 }
341
342
343 /********************************************************************
344 *
345 * btrim
346 *
347 * Syntax:
348 *
349 * text btrim(text string, text set)
350 *
351 * Purpose:
352 *
353 * Returns string with characters removed from the front and back
354 * up to the first character not in set.
355 *
356 ********************************************************************/
357
358 Datum
359 btrim(PG_FUNCTION_ARGS)
360 {
361 text *string = PG_GETARG_TEXT_PP(0);
362 text *set = PG_GETARG_TEXT_PP(1);
363 text *ret;
364
365 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
366 VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
367 true, true);
368
369 PG_RETURN_TEXT_P(ret);
370 }
371
372 /********************************************************************
373 *
374 * btrim1 --- btrim with set fixed as ' '
375 *
376 ********************************************************************/
377
378 Datum
379 btrim1(PG_FUNCTION_ARGS)
380 {
381 text *string = PG_GETARG_TEXT_PP(0);
382 text *ret;
383
384 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
385 " ", 1,
386 true, true);
387
388 PG_RETURN_TEXT_P(ret);
389 }
390
391 /*
392 * Common implementation for btrim, ltrim, rtrim
393 */
394 static text *
395 dotrim(const char *string, int stringlen,
396 const char *set, int setlen,
397 bool doltrim, bool dortrim)
398 {
399 int i;
400
401 /* Nothing to do if either string or set is empty */
402 if (stringlen > 0 && setlen > 0)
403 {
404 if (pg_database_encoding_max_length() > 1)
405 {
406 /*
407 * In the multibyte-encoding case, build arrays of pointers to
408 * character starts, so that we can avoid inefficient checks in
409 * the inner loops.
410 */
411 const char **stringchars;
412 const char **setchars;
413 const char *setend;
414 int *stringmblen;
415 int *setmblen;
416 int stringnchars;
417 int setnchars;
418 int resultndx;
419 int resultnchars;
420 const char *p;
421 const char *pend;
422 int len;
423 int mblen;
424 const char *str_pos;
425 int str_len;
426
427 stringchars = (const char **) palloc(stringlen * sizeof(char *));
428 stringmblen = (int *) palloc(stringlen * sizeof(int));
429 stringnchars = 0;
430 p = string;
431 len = stringlen;
432 pend = p + len;
433 while (len > 0)
434 {
435 stringchars[stringnchars] = p;
436 stringmblen[stringnchars] = mblen = pg_mblen_range(p, pend);
437 stringnchars++;
438 p += mblen;
439 len -= mblen;
440 }
441
442 setchars = (const char **) palloc(setlen * sizeof(char *));
443 setmblen = (int *) palloc(setlen * sizeof(int));
444 setnchars = 0;
445 p = set;
446 len = setlen;
447 setend = set + setlen;
448 while (len > 0)
449 {
450 setchars[setnchars] = p;
451 setmblen[setnchars] = mblen = pg_mblen_range(p, setend);
452 setnchars++;
453 p += mblen;
454 len -= mblen;
455 }
456
457 resultndx = 0; /* index in stringchars[] */
458 resultnchars = stringnchars;
459
460 if (doltrim)
461 {
462 while (resultnchars > 0)
463 {
464 str_pos = stringchars[resultndx];
465 str_len = stringmblen[resultndx];
466 for (i = 0; i < setnchars; i++)
467 {
468 if (str_len == setmblen[i] &&
469 memcmp(str_pos, setchars[i], str_len) == 0)
470 break;
471 }
472 if (i >= setnchars)
473 break; /* no match here */
474 string += str_len;
475 stringlen -= str_len;
476 resultndx++;
477 resultnchars--;
478 }
479 }
480
481 if (dortrim)
482 {
483 while (resultnchars > 0)
484 {
485 str_pos = stringchars[resultndx + resultnchars - 1];
486 str_len = stringmblen[resultndx + resultnchars - 1];
487 for (i = 0; i < setnchars; i++)
488 {
489 if (str_len == setmblen[i] &&
490 memcmp(str_pos, setchars[i], str_len) == 0)
491 break;
492 }
493 if (i >= setnchars)
494 break; /* no match here */
495 stringlen -= str_len;
496 resultnchars--;
497 }
498 }
499
500 pfree(stringchars);
501 pfree(stringmblen);
502 pfree(setchars);
503 pfree(setmblen);
504 }
505 else
506 {
507 /*
508 * In the single-byte-encoding case, we don't need such overhead.
509 */
510 if (doltrim)
511 {
512 while (stringlen > 0)
513 {
514 char str_ch = *string;
515
516 for (i = 0; i < setlen; i++)
517 {
518 if (str_ch == set[i])
519 break;
520 }
521 if (i >= setlen)
522 break; /* no match here */
523 string++;
524 stringlen--;
525 }
526 }
527
528 if (dortrim)
529 {
530 while (stringlen > 0)
531 {
532 char str_ch = string[stringlen - 1];
533
534 for (i = 0; i < setlen; i++)
535 {
536 if (str_ch == set[i])
537 break;
538 }
539 if (i >= setlen)
540 break; /* no match here */
541 stringlen--;
542 }
543 }
544 }
545 }
546
547 /* Return selected portion of string */
548 return cstring_to_text_with_len(string, stringlen);
549 }
550
551 /*
552 * Common implementation for bytea versions of btrim, ltrim, rtrim
553 */
554 bytea *
555 dobyteatrim(bytea *string, bytea *set, bool doltrim, bool dortrim)
556 {
557 bytea *ret;
558 char *ptr,
559 *end,
560 *ptr2,
561 *ptr2start,
562 *end2;
563 int m,
564 stringlen,
565 setlen;
566
567 stringlen = VARSIZE_ANY_EXHDR(string);
568 setlen = VARSIZE_ANY_EXHDR(set);
569
570 if (stringlen <= 0 || setlen <= 0)
571 return string;
572
573 m = stringlen;
574 ptr = VARDATA_ANY(string);
575 end = ptr + stringlen - 1;
576 ptr2start = VARDATA_ANY(set);
577 end2 = ptr2start + setlen - 1;
578
579 if (doltrim)
580 {
581 while (m > 0)
582 {
583 ptr2 = ptr2start;
584 while (ptr2 <= end2)
585 {
586 if (*ptr == *ptr2)
587 break;
588 ++ptr2;
589 }
590 if (ptr2 > end2)
591 break;
592 ptr++;
593 m--;
594 }
595 }
596
597 if (dortrim)
598 {
599 while (m > 0)
600 {
601 ptr2 = ptr2start;
602 while (ptr2 <= end2)
603 {
604 if (*end == *ptr2)
605 break;
606 ++ptr2;
607 }
608 if (ptr2 > end2)
609 break;
610 end--;
611 m--;
612 }
613 }
614
615 ret = (bytea *) palloc(VARHDRSZ + m);
616 SET_VARSIZE(ret, VARHDRSZ + m);
617 memcpy(VARDATA(ret), ptr, m);
618 return ret;
619 }
620
621 /********************************************************************
622 *
623 * byteatrim
624 *
625 * Syntax:
626 *
627 * bytea byteatrim(bytea string, bytea set)
628 *
629 * Purpose:
630 *
631 * Returns string with characters removed from the front and back
632 * up to the first character not in set.
633 *
634 * Cloned from btrim and modified as required.
635 ********************************************************************/
636
637 Datum
638 byteatrim(PG_FUNCTION_ARGS)
639 {
640 bytea *string = PG_GETARG_BYTEA_PP(0);
641 bytea *set = PG_GETARG_BYTEA_PP(1);
642 bytea *ret;
643
644 ret = dobyteatrim(string, set, true, true);
645
646 PG_RETURN_BYTEA_P(ret);
647 }
648
649 /********************************************************************
650 *
651 * bytealtrim
652 *
653 * Syntax:
654 *
655 * bytea bytealtrim(bytea string, bytea set)
656 *
657 * Purpose:
658 *
659 * Returns string with initial characters removed up to the first
660 * character not in set.
661 *
662 ********************************************************************/
663
664 Datum
665 bytealtrim(PG_FUNCTION_ARGS)
666 {
667 bytea *string = PG_GETARG_BYTEA_PP(0);
668 bytea *set = PG_GETARG_BYTEA_PP(1);
669 bytea *ret;
670
671 ret = dobyteatrim(string, set, true, false);
672
673 PG_RETURN_BYTEA_P(ret);
674 }
675
676 /********************************************************************
677 *
678 * byteartrim
679 *
680 * Syntax:
681 *
682 * bytea byteartrim(bytea string, bytea set)
683 *
684 * Purpose:
685 *
686 * Returns string with final characters removed after the last
687 * character not in set.
688 *
689 ********************************************************************/
690
691 Datum
692 byteartrim(PG_FUNCTION_ARGS)
693 {
694 bytea *string = PG_GETARG_BYTEA_PP(0);
695 bytea *set = PG_GETARG_BYTEA_PP(1);
696 bytea *ret;
697
698 ret = dobyteatrim(string, set, false, true);
699
700 PG_RETURN_BYTEA_P(ret);
701 }
702
703 /********************************************************************
704 *
705 * ltrim
706 *
707 * Syntax:
708 *
709 * text ltrim(text string, text set)
710 *
711 * Purpose:
712 *
713 * Returns string with initial characters removed up to the first
714 * character not in set.
715 *
716 ********************************************************************/
717
718 Datum
719 ltrim(PG_FUNCTION_ARGS)
720 {
721 text *string = PG_GETARG_TEXT_PP(0);
722 text *set = PG_GETARG_TEXT_PP(1);
723 text *ret;
724
725 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
726 VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
727 true, false);
728
729 PG_RETURN_TEXT_P(ret);
730 }
731
732 /********************************************************************
733 *
734 * ltrim1 --- ltrim with set fixed as ' '
735 *
736 ********************************************************************/
737
738 Datum
739 ltrim1(PG_FUNCTION_ARGS)
740 {
741 text *string = PG_GETARG_TEXT_PP(0);
742 text *ret;
743
744 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
745 " ", 1,
746 true, false);
747
748 PG_RETURN_TEXT_P(ret);
749 }
750
751 /********************************************************************
752 *
753 * rtrim
754 *
755 * Syntax:
756 *
757 * text rtrim(text string, text set)
758 *
759 * Purpose:
760 *
761 * Returns string with final characters removed after the last
762 * character not in set.
763 *
764 ********************************************************************/
765
766 Datum
767 rtrim(PG_FUNCTION_ARGS)
768 {
769 text *string = PG_GETARG_TEXT_PP(0);
770 text *set = PG_GETARG_TEXT_PP(1);
771 text *ret;
772
773 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
774 VARDATA_ANY(set), VARSIZE_ANY_EXHDR(set),
775 false, true);
776
777 PG_RETURN_TEXT_P(ret);
778 }
779
780 /********************************************************************
781 *
782 * rtrim1 --- rtrim with set fixed as ' '
783 *
784 ********************************************************************/
785
786 Datum
787 rtrim1(PG_FUNCTION_ARGS)
788 {
789 text *string = PG_GETARG_TEXT_PP(0);
790 text *ret;
791
792 ret = dotrim(VARDATA_ANY(string), VARSIZE_ANY_EXHDR(string),
793 " ", 1,
794 false, true);
795
796 PG_RETURN_TEXT_P(ret);
797 }
798
799
800 /********************************************************************
801 *
802 * translate
803 *
804 * Syntax:
805 *
806 * text translate(text string, text from, text to)
807 *
808 * Purpose:
809 *
810 * Returns string after replacing all occurrences of characters in from
811 * with the corresponding character in to. If from is longer than to,
812 * occurrences of the extra characters in from are deleted.
813 * Improved by Edwin Ramirez <[email protected]>.
814 *
815 ********************************************************************/
816
817 Datum
818 translate(PG_FUNCTION_ARGS)
819 {
820 text *string = PG_GETARG_TEXT_PP(0);
821 text *from = PG_GETARG_TEXT_PP(1);
822 text *to = PG_GETARG_TEXT_PP(2);
823 text *result;
824 char *from_ptr,
825 *to_ptr,
826 *to_end;
827 char *source,
828 *target;
829 const char *source_end;
830 const char *from_end;
831 int m,
832 fromlen,
833 tolen,
834 retlen,
835 i;
836 int bytelen;
837 int len;
838 int source_len;
839 int from_index;
840
841 m = VARSIZE_ANY_EXHDR(string);
842 if (m <= 0)
843 PG_RETURN_TEXT_P(string);
844 source = VARDATA_ANY(string);
845 source_end = source + m;
846
847 fromlen = VARSIZE_ANY_EXHDR(from);
848 from_ptr = VARDATA_ANY(from);
849 from_end = from_ptr + fromlen;
850 tolen = VARSIZE_ANY_EXHDR(to);
851 to_ptr = VARDATA_ANY(to);
852 to_end = to_ptr + tolen;
853
854 /*
855 * The worst-case expansion is to substitute a max-length character for a
856 * single-byte character at each position of the string.
857 */
858 if (unlikely(pg_mul_s32_overflow(pg_database_encoding_max_length(), m,
859 &bytelen)) ||
860 unlikely(pg_add_s32_overflow(bytelen, VARHDRSZ, &bytelen)) ||
861 unlikely(!AllocSizeIsValid(bytelen)))
862 ereport(ERROR,
863 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
864 errmsg("requested length too large")));
865
866 result = (text *) palloc(bytelen);
867
868 target = VARDATA(result);
869 retlen = 0;
870
871 while (m > 0)
872 {
873 source_len = pg_mblen_range(source, source_end);
874 from_index = 0;
875
876 for (i = 0; i < fromlen; i += len)
877 {
878 len = pg_mblen_range(&from_ptr[i], from_end);
879 if (len == source_len &&
880 memcmp(source, &from_ptr[i], len) == 0)
881 break;
882
883 from_index++;
884 }
885 if (i < fromlen)
886 {
887 /* substitute, or delete if no corresponding "to" character */
888 char *p = to_ptr;
889
890 for (i = 0; i < from_index; i++)
891 {
892 if (p >= to_end)
893 break;
894 p += pg_mblen_range(p, to_end);
895 }
896 if (p < to_end)
897 {
898 len = pg_mblen_range(p, to_end);
899 memcpy(target, p, len);
900 target += len;
901 retlen += len;
902 }
903 }
904 else
905 {
906 /* no match, so copy */
907 memcpy(target, source, source_len);
908 target += source_len;
909 retlen += source_len;
910 }
911
912 source += source_len;
913 m -= source_len;
914 }
915
916 SET_VARSIZE(result, retlen + VARHDRSZ);
917
918 /*
919 * The function result is probably much bigger than needed, if we're using
920 * a multibyte encoding, but it's not worth reallocating it; the result
921 * probably won't live long anyway.
922 */
923
924 PG_RETURN_TEXT_P(result);
925 }
926
927 /********************************************************************
928 *
929 * ascii
930 *
931 * Syntax:
932 *
933 * int ascii(text string)
934 *
935 * Purpose:
936 *
937 * Returns the decimal representation of the first character from
938 * string.
939 * If the string is empty we return 0.
940 * If the database encoding is UTF8, we return the Unicode codepoint.
941 * If the database encoding is any other multi-byte encoding, we
942 * return the value of the first byte if it is an ASCII character
943 * (range 1 .. 127), or raise an error.
944 * For all other encodings we return the value of the first byte,
945 * (range 1..255).
946 *
947 ********************************************************************/
948
949 Datum
950 ascii(PG_FUNCTION_ARGS)
951 {
952 text *string = PG_GETARG_TEXT_PP(0);
953 int encoding = GetDatabaseEncoding();
954 unsigned char *data;
955 int len;
956
957 len = VARSIZE_ANY_EXHDR(string);
958 if (len <= 0)
959 PG_RETURN_INT32(0);
960
961 data = (unsigned char *) VARDATA_ANY(string);
962
963 if (encoding == PG_UTF8 && *data > 127)
964 {
965 /* return the code point for Unicode */
966
967 int result = 0,
968 tbytes = 0,
969 i;
970
971 if (*data >= 0xF0)
972 {
973 result = *data & 0x07;
974 tbytes = 3;
975 }
976 else if (*data >= 0xE0)
977 {
978 result = *data & 0x0F;
979 tbytes = 2;
980 }
981 else if (*data > 0xC0)
982 {
983 result = *data & 0x1f;
984 tbytes = 1;
985 }
986 else
987 ereport(ERROR,
988 (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
989 errmsg("invalid byte sequence for encoding \"%s\"",
990 GetDatabaseEncodingName())));
991
992 /* All continuation bytes are present in the input */
993 if (tbytes >= len)
994 ereport(ERROR,
995 (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
996 errmsg("invalid byte sequence for encoding \"%s\"",
997 GetDatabaseEncodingName())));
998
999 for (i = 1; i <= tbytes; i++)
1000 {
1001 if (unlikely((data[i] & 0xC0) != 0x80))
1002 ereport(ERROR,
1003 (errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
1004 errmsg("invalid byte sequence for encoding \"%s\"",
1005 GetDatabaseEncodingName())));
1006 result = (result << 6) + (data[i] & 0x3f);
1007 }
1008
1009 PG_RETURN_INT32(result);
1010 }
1011 else
1012 {
1013 if (pg_encoding_max_length(encoding) > 1 && *data > 127)
1014 ereport(ERROR,
1015 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1016 errmsg("requested character too large")));
1017
1018
1019 PG_RETURN_INT32((int32) *data);
1020 }
1021 }
1022
1023 /********************************************************************
1024 *
1025 * chr
1026 *
1027 * Syntax:
1028 *
1029 * text chr(int val)
1030 *
1031 * Purpose:
1032 *
1033 * Returns the character having the binary equivalent to val.
1034 *
1035 * For UTF8 we treat the argument as a Unicode code point.
1036 * For other multi-byte encodings we raise an error for arguments
1037 * outside the strict ASCII range (1..127).
1038 *
1039 * It's important that we don't ever return a value that is not valid
1040 * in the database encoding, so that this doesn't become a way for
1041 * invalid data to enter the database.
1042 *
1043 ********************************************************************/
1044
1045 Datum
1046 chr (PG_FUNCTION_ARGS)
1047 {
1048 int32 arg = PG_GETARG_INT32(0);
1049 uint32 cvalue;
1050 text *result;
1051 int encoding = GetDatabaseEncoding();
1052
1053 /*
1054 * Error out on arguments that make no sense or that we can't validly
1055 * represent in the encoding.
1056 */
1057 if (arg < 0)
1058 ereport(ERROR,
1059 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1060 errmsg("character number must be positive")));
1061 else if (arg == 0)
1062 ereport(ERROR,
1063 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1064 errmsg("null character not permitted")));
1065
1066 cvalue = arg;
1067
1068 if (encoding == PG_UTF8 && cvalue > 127)
1069 {
1070 /* for Unicode we treat the argument as a code point */
1071 int bytes;
1072 unsigned char *wch;
1073
1074 /*
1075 * We only allow valid Unicode code points; per RFC3629 that stops at
1076 * U+10FFFF, even though 4-byte UTF8 sequences can hold values up to
1077 * U+1FFFFF.
1078 */
1079 if (cvalue > 0x0010ffff)
1080 ereport(ERROR,
1081 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1082 errmsg("requested character too large for encoding: %u",
1083 cvalue)));
1084
1085 if (cvalue > 0xffff)
1086 bytes = 4;
1087 else if (cvalue > 0x07ff)
1088 bytes = 3;
1089 else
1090 bytes = 2;
1091
1092 result = (text *) palloc(VARHDRSZ + bytes);
1093 SET_VARSIZE(result, VARHDRSZ + bytes);
1094 wch = (unsigned char *) VARDATA(result);
1095
1096 if (bytes == 2)
1097 {
1098 wch[0] = 0xC0 | ((cvalue >> 6) & 0x1F);
1099 wch[1] = 0x80 | (cvalue & 0x3F);
1100 }
1101 else if (bytes == 3)
1102 {
1103 wch[0] = 0xE0 | ((cvalue >> 12) & 0x0F);
1104 wch[1] = 0x80 | ((cvalue >> 6) & 0x3F);
1105 wch[2] = 0x80 | (cvalue & 0x3F);
1106 }
1107 else
1108 {
1109 wch[0] = 0xF0 | ((cvalue >> 18) & 0x07);
1110 wch[1] = 0x80 | ((cvalue >> 12) & 0x3F);
1111 wch[2] = 0x80 | ((cvalue >> 6) & 0x3F);
1112 wch[3] = 0x80 | (cvalue & 0x3F);
1113 }
1114
1115 /*
1116 * The preceding range check isn't sufficient, because UTF8 excludes
1117 * Unicode "surrogate pair" codes. Make sure what we created is valid
1118 * UTF8.
1119 */
1120 if (!pg_utf8_islegal(wch, bytes))
1121 ereport(ERROR,
1122 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1123 errmsg("requested character not valid for encoding: %u",
1124 cvalue)));
1125 }
1126 else
1127 {
1128 bool is_mb;
1129
1130 is_mb = pg_encoding_max_length(encoding) > 1;
1131
1132 if ((is_mb && (cvalue > 127)) || (!is_mb && (cvalue > 255)))
1133 ereport(ERROR,
1134 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1135 errmsg("requested character too large for encoding: %u",
1136 cvalue)));
1137
1138 result = (text *) palloc(VARHDRSZ + 1);
1139 SET_VARSIZE(result, VARHDRSZ + 1);
1140 *VARDATA(result) = (char) cvalue;
1141 }
1142
1143 PG_RETURN_TEXT_P(result);
1144 }
1145
1146 /********************************************************************
1147 *
1148 * repeat
1149 *
1150 * Syntax:
1151 *
1152 * text repeat(text string, int val)
1153 *
1154 * Purpose:
1155 *
1156 * Repeat string by val.
1157 *
1158 ********************************************************************/
1159
1160 Datum
1161 repeat(PG_FUNCTION_ARGS)
1162 {
1163 text *string = PG_GETARG_TEXT_PP(0);
1164 int32 count = PG_GETARG_INT32(1);
1165 text *result;
1166 int slen,
1167 tlen;
1168 int i;
1169 char *cp,
1170 *sp;
1171
1172 if (count < 0)
1173 count = 0;
1174
1175 slen = VARSIZE_ANY_EXHDR(string);
1176
1177 if (unlikely(pg_mul_s32_overflow(count, slen, &tlen)) ||
1178 unlikely(pg_add_s32_overflow(tlen, VARHDRSZ, &tlen)) ||
1179 unlikely(!AllocSizeIsValid(tlen)))
1180 ereport(ERROR,
1181 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1182 errmsg("requested length too large")));
1183
1184 result = (text *) palloc(tlen);
1185
1186 SET_VARSIZE(result, tlen);
1187 cp = VARDATA(result);
1188 sp = VARDATA_ANY(string);
1189 for (i = 0; i < count; i++)
1190 {
1191 memcpy(cp, sp, slen);
1192 cp += slen;
1193 CHECK_FOR_INTERRUPTS();
1194 }
1195
1196 PG_RETURN_TEXT_P(result);
1197 }