| blob | 34796f2e27ce4e23ba215ffbf15a8a70c5dc85d1 |
1 /*-------------------------------------------------------------------------
2 *
3 * varlena.c
4 * Functions for the variable-length built-in types.
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/utils/adt/varlena.c
12 *
13 *-------------------------------------------------------------------------
14 */
17 #include <ctype.h>
18 #include <limits.h>
47 /* GUC variable */
52 /*
53 * State for text_position_* functions.
54 */
56 {
64 /* Skip table for Boyer-Moore-Horspool search algorithm: */
70 /*
71 * Sometimes we need to convert the byte position of a match to a
72 * character position. These store the last position that was converted,
73 * so that on the next call, we can continue from that point, rather than
74 * count characters from the very beginning.
75 */
81 {
83 * buf */
96 pg_locale_t locale;
99 /*
100 * Output data for split_text(): we output either to an array or a table.
101 * tupstore and tupdesc must be set up in advance to output to a table.
102 */
104 {
107 TupleDesc tupdesc;
110 /*
111 * This should be large enough that most strings will fit, but small enough
112 * that we feel comfortable putting it on the stack
113 */
114 #define TEXTBUFLEN 1024
116 #define DatumGetVarStringP(X) ((VarString *) PG_DETOAST_DATUM(X))
117 #define DatumGetVarStringPP(X) ((VarString *) PG_DETOAST_DATUM_PACKED(X))
130 int32 start,
131 int32 length,
154 Oid collation);
172 /*****************************************************************************
173 * CONVERSION ROUTINES EXPORTED FOR USE BY C CODE *
174 *****************************************************************************/
176 /*
177 * cstring_to_text
178 *
179 * Create a text value from a null-terminated C string.
180 *
181 * The new text value is freshly palloc'd with a full-size VARHDR.
182 */
183 text *
185 {
187 }
189 /*
190 * cstring_to_text_with_len
191 *
192 * Same as cstring_to_text except the caller specifies the string length;
193 * the string need not be null_terminated.
194 */
195 text *
197 {
204 }
206 /*
207 * text_to_cstring
208 *
209 * Create a palloc'd, null-terminated C string from a text value.
210 *
211 * We support being passed a compressed or toasted text value.
212 * This is a bit bogus since such values shouldn't really be referred to as
213 * "text *", but it seems useful for robustness. If we didn't handle that
214 * case here, we'd need another routine that did, anyway.
215 */
218 {
219 /* must cast away the const, unfortunately */
232 }
234 /*
235 * text_to_cstring_buffer
236 *
237 * Copy a text value into a caller-supplied buffer of size dst_len.
238 *
239 * The text string is truncated if necessary to fit. The result is
240 * guaranteed null-terminated (unless dst_len == 0).
241 *
242 * We support being passed a compressed or toasted text value.
243 * This is a bit bogus since such values shouldn't really be referred to as
244 * "text *", but it seems useful for robustness. If we didn't handle that
245 * case here, we'd need another routine that did, anyway.
246 */
247 void
249 {
250 /* must cast away the const, unfortunately */
255 {
256 dst_len--;
263 }
267 }
270 /*****************************************************************************
271 * USER I/O ROUTINES *
272 *****************************************************************************/
278 /*
279 * byteain - converts from printable representation of byte array
280 *
281 * Non-printable characters must be passed as '\nnn' (octal) and are
282 * converted to internal form. '\' must be passed as '\\'.
283 * ereport(ERROR, ...) if bad form.
284 *
285 * BUGS:
286 * The input is scanned twice.
287 * The error checking of input is minimal.
288 */
289 Datum
291 {
299 /* Recognize hex input */
301 {
307 escontext);
311 }
313 /* Else, it's the traditional escaped style */
315 {
317 tp++;
326 else
327 {
328 /*
329 * one backslash, not followed by another or ### valid octal
330 */
334 }
335 }
345 {
352 {
360 }
363 {
366 }
367 else
368 {
369 /*
370 * We should never get here. The first pass should not allow it.
371 */
375 }
376 }
379 }
381 /*
382 * byteaout - converts to printable representation of byte array
383 *
384 * In the traditional escaped format, non-printable characters are
385 * printed as '\nnn' (octal) and '\' as '\\'.
386 */
387 Datum
389 {
395 {
396 /* Print hex format */
401 }
403 {
404 /* Print traditional escaped format */
406 uint64 len;
412 {
417 else
418 len++;
419 }
421 /*
422 * In principle len can't overflow uint32 if the input fit in 1GB, but
423 * for safety let's check rather than relying on palloc's internal
424 * check.
425 */
434 {
436 {
439 }
441 {
452 }
453 else
455 }
456 }
457 else
458 {
460 bytea_output);
462 }
465 }
467 /*
468 * bytearecv - converts external binary format to bytea
469 */
470 Datum
472 {
482 }
484 /*
485 * byteasend - converts bytea to binary format
486 *
487 * This is a special case: just copy the input...
488 */
489 Datum
491 {
495 }
497 Datum
499 {
500 StringInfo state;
504 /* Append the value unless null, preceding it with the delimiter. */
506 {
510 /*
511 * You might think we can just throw away the first delimiter, however
512 * we must keep it as we may be a parallel worker doing partial
513 * aggregation building a state to send to the main process. We need
514 * to keep the delimiter of every aggregation so that the combine
515 * function can properly join up the strings of two separately
516 * partially aggregated results. The first delimiter is only stripped
517 * off in the final function. To know how much to strip off the front
518 * of the string, we store the length of the first delimiter in the
519 * StringInfo's cursor field, which we don't otherwise need here.
520 */
522 {
525 }
528 {
535 }
539 }
541 /*
542 * The transition type for string_agg() is declared to be "internal",
543 * which is a pass-by-value type the same size as a pointer.
544 */
548 }
550 Datum
552 {
553 StringInfo state;
555 /* cannot be called directly because of internal-type argument */
561 {
562 /* As per comment in transfn, strip data before the cursor position */
570 }
571 else
573 }
575 /*
576 * textin - converts cstring to internal representation
577 */
578 Datum
580 {
584 }
586 /*
587 * textout - converts internal representation to cstring
588 */
589 Datum
591 {
595 }
597 /*
598 * textrecv - converts external binary format to text
599 */
600 Datum
602 {
613 }
615 /*
616 * textsend - converts text to binary format
617 */
618 Datum
620 {
622 StringInfoData buf;
627 }
630 /*
631 * unknownin - converts cstring to internal representation
632 */
633 Datum
635 {
638 /* representation is same as cstring */
640 }
642 /*
643 * unknownout - converts internal representation to cstring
644 */
645 Datum
647 {
648 /* representation is same as cstring */
652 }
654 /*
655 * unknownrecv - converts external binary format to unknown
656 */
657 Datum
659 {
665 /* representation is same as cstring */
667 }
669 /*
670 * unknownsend - converts unknown to binary format
671 */
672 Datum
674 {
675 /* representation is same as cstring */
677 StringInfoData buf;
682 }
685 /* ========== PUBLIC ROUTINES ========== */
687 /*
688 * textlen -
689 * returns the logical length of a text*
690 * (which is less than the VARSIZE of the text*)
691 */
692 Datum
694 {
697 /* try to avoid decompressing argument */
699 }
701 /*
702 * text_length -
703 * Does the real work for textlen()
704 *
705 * This is broken out so it can be called directly by other string processing
706 * functions. Note that the argument is passed as a Datum, to indicate that
707 * it may still be in compressed form. We can avoid decompressing it at all
708 * in some cases.
709 */
710 static int32
712 {
713 /* fastpath when max encoding length is one */
716 else
717 {
722 }
723 }
725 /*
726 * textoctetlen -
727 * returns the physical length of a text*
728 * (which is less than the VARSIZE of the text*)
729 */
730 Datum
732 {
735 /* We need not detoast the input at all */
737 }
739 /*
740 * textcat -
741 * takes two text* and returns a text* that is the concatenation of
742 * the two.
743 *
744 * Rewritten by Sapa, sapa@hq.icb.chel.su. 8-Jul-96.
745 * Updated by Thomas, Thomas.Lockhart@jpl.nasa.gov 1997-07-10.
746 * Allocate space for output in all cases.
747 * XXX - thomas 1997-07-10
748 */
749 Datum
751 {
756 }
758 /*
759 * text_catenate
760 * Guts of textcat(), broken out so it can be used by other functions
761 *
762 * Arguments can be in short-header form, but not compressed or out-of-line
763 */
766 {
769 len2,
770 len;
776 /* paranoia ... probably should throw error instead? */
785 /* Set size of result string... */
788 /* Fill data field of result string... */
796 }
798 /*
799 * charlen_to_bytelen()
800 * Compute the number of bytes occupied by n characters starting at *p
801 *
802 * It is caller's responsibility that there actually are n characters;
803 * the string need not be null-terminated.
804 */
805 static int
807 {
809 {
810 /* Optimization for single-byte encodings */
812 }
813 else
814 {
821 }
822 }
824 /*
825 * text_substr()
826 * Return a substring starting at the specified position.
827 * - thomas 1997-12-31
828 *
829 * Input:
830 * - string
831 * - starting position (is one-based)
832 * - string length
833 *
834 * If the starting position is zero or less, then return from the start of the string
835 * adjusting the length to be consistent with the "negative start" per SQL.
836 * If the length is less than zero, return the remaining string.
837 *
838 * Added multibyte support.
839 * - Tatsuo Ishii 1998-4-21
840 * Changed behavior if starting position is less than one to conform to SQL behavior.
841 * Formerly returned the entire string; now returns a portion.
842 * - Thomas Lockhart 1998-12-10
843 * Now uses faster TOAST-slicing interface
844 * - John Gray 2002-02-22
845 * Remove "#ifdef MULTIBYTE" and test for encoding_max_length instead. Change
846 * behaviors conflicting with SQL to meet SQL (if E = S + L < S throw
847 * error; if E < 1, return '', not entire string). Fixed MB related bug when
848 * S > LC and < LC + 4 sometimes garbage characters are returned.
849 * - Joe Conway 2002-08-10
850 */
851 Datum
853 {
858 }
860 /*
861 * text_substr_no_len -
862 * Wrapper to avoid opr_sanity failure due to
863 * one function accepting a different number of args.
864 */
865 Datum
867 {
871 }
873 /*
874 * text_substring -
875 * Does the real work for text_substr() and text_substr_no_len()
876 *
877 * This is broken out so it can be called directly by other string processing
878 * functions. Note that the argument is passed as a Datum, to indicate that
879 * it may still be in compressed/toasted form. We can avoid detoasting all
880 * of it in some cases.
881 *
882 * The result is always a freshly palloc'd datum.
883 */
886 {
893 /*
894 * SQL99 says S can be zero or negative (which we don't document), but we
895 * still must fetch from the start of the string.
896 * https://www.postgresql.org/message-id/170905442373.643.11536838320909376197%40wrigleys.postgresql.org
897 */
900 /* life is easy if the encoding max length is 1 */
902 {
904 * string */
907 {
908 /* SQL99 says to throw an error for E < S, i.e., negative length */
913 }
915 {
916 /*
917 * L could be large enough for S + L to overflow, in which case
918 * the substring must run to end of string.
919 */
921 }
922 else
923 {
924 /*
925 * A zero or negative value for the end position can happen if the
926 * start was negative or one. SQL99 says to return a zero-length
927 * string.
928 */
933 }
935 /*
936 * If the start position is past the end of the string, SQL99 says to
937 * return a zero-length string -- DatumGetTextPSlice() will do that
938 * for us. We need only convert S1 to zero-based starting position.
939 */
941 }
943 {
944 /*
945 * When encoding max length is > 1, we can't get LC without
946 * detoasting, so we'll grab a conservatively large slice now and go
947 * back later to do the right thing
948 */
949 int32 slice_start;
950 int32 slice_size;
951 int32 slice_strlen;
953 int32 E1;
954 int32 i;
959 /*
960 * We need to start at position zero because there is no way to know
961 * in advance which byte offset corresponds to the supplied start
962 * position.
963 */
967 * string */
970 {
971 /* SQL99 says to throw an error for E < S, i.e., negative length */
976 }
978 {
979 /*
980 * L could be large enough for S + L to overflow, in which case
981 * the substring must run to end of string.
982 */
984 }
985 else
986 {
987 /*
988 * A zero or negative value for the end position can happen if the
989 * start was negative or one. SQL99 says to return a zero-length
990 * string.
991 */
995 /*
996 * if E is past the end of the string, the tuple toaster will
997 * truncate the length for us
998 */
1001 /*
1002 * Total slice size in bytes can't be any longer than the start
1003 * position plus substring length times the encoding max length.
1004 * If that overflows, we can just use -1.
1005 */
1008 }
1010 /*
1011 * If we're working with an untoasted source, no need to do an extra
1012 * copying step.
1013 */
1017 else
1020 /* see if we got back an empty string */
1022 {
1026 }
1028 /* Now we can get the actual length of the slice in MB characters */
1032 /*
1033 * Check that the start position wasn't > slice_strlen. If so, SQL99
1034 * says to return a zero-length string.
1035 */
1037 {
1041 }
1043 /*
1044 * Adjust L1 and E1 now that we know the slice string length. Again
1045 * remember that S1 is one based, and slice_start is zero based.
1046 */
1049 else
1052 /*
1053 * Find the start position in the slice; remember S1 is not zero based
1054 */
1059 /* hang onto a pointer to our start position */
1062 /*
1063 * Count the actual bytes used by the substring of the requested
1064 * length.
1065 */
1077 }
1078 else
1081 /* not reached: suppress compiler warning */
1083 }
1085 /*
1086 * textoverlay
1087 * Replace specified substring of first string with second
1088 *
1089 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
1090 * This code is a direct implementation of what the standard says.
1091 */
1092 Datum
1094 {
1101 }
1103 Datum
1105 {
1113 }
1117 {
1123 /*
1124 * Check for possible integer-overflow cases. For negative sp, throw a
1125 * "substring length" error because that's what should be expected
1126 * according to the spec's definition of OVERLAY().
1127 */
1143 }
1145 /*
1146 * textpos -
1147 * Return the position of the specified substring.
1148 * Implements the SQL POSITION() function.
1149 * Ref: A Guide To The SQL Standard, Date & Darwen, 1997
1150 * - thomas 1997-07-27
1151 */
1152 Datum
1154 {
1159 }
1161 /*
1162 * text_position -
1163 * Does the real work for textpos()
1164 *
1165 * Inputs:
1166 * t1 - string to be searched
1167 * t2 - pattern to match within t1
1168 * Result:
1169 * Character index of the first matched char, starting from 1,
1170 * or 0 if no match.
1171 *
1172 * This is broken out so it can be called directly by other string processing
1173 * functions.
1174 */
1175 static int
1177 {
1178 TextPositionState state;
1181 /* Empty needle always matches at position 1 */
1185 /* Otherwise, can't match if haystack is shorter than needle */
1192 else
1196 }
1199 /*
1200 * text_position_setup, text_position_next, text_position_cleanup -
1201 * Component steps of text_position()
1202 *
1203 * These are broken out so that a string can be efficiently searched for
1204 * multiple occurrences of the same pattern. text_position_next may be
1205 * called multiple times, and it advances to the next match on each call.
1206 * text_position_get_match_ptr() and text_position_get_match_pos() return
1207 * a pointer or 1-based character position of the last match, respectively.
1208 *
1209 * The "state" variable is normally just a local variable in the caller.
1210 *
1211 * NOTE: text_position_next skips over the matched portion. For example,
1212 * searching for "xx" in "xxx" returns only one match, not two.
1213 */
1215 static void
1217 {
1220 pg_locale_t mylocale;
1234 /*
1235 * Even with a multi-byte encoding, we perform the search using the raw
1236 * byte sequence, ignoring multibyte issues. For UTF-8, that works fine,
1237 * because in UTF-8 the byte sequence of one character cannot contain
1238 * another character. For other multi-byte encodings, we do the search
1239 * initially as a simple byte search, ignoring multibyte issues, but
1240 * verify afterwards that the match we found is at a character boundary,
1241 * and continue the search if it was a false match.
1242 */
1247 else
1258 /*
1259 * Prepare the skip table for Boyer-Moore-Horspool searching. In these
1260 * notes we use the terminology that the "haystack" is the string to be
1261 * searched (t1) and the "needle" is the pattern being sought (t2).
1262 *
1263 * If the needle is empty or bigger than the haystack then there is no
1264 * point in wasting cycles initializing the table. We also choose not to
1265 * use B-M-H for needles of length 1, since the skip table can't possibly
1266 * save anything in that case.
1267 */
1269 {
1276 /*
1277 * First we must determine how much of the skip table to use. The
1278 * declaration of TextPositionState allows up to 256 elements, but for
1279 * short search problems we don't really want to have to initialize so
1280 * many elements --- it would take too long in comparison to the
1281 * actual search time. So we choose a useful skip table size based on
1282 * the haystack length minus the needle length. The closer the needle
1283 * length is to the haystack length the less useful skipping becomes.
1284 *
1285 * Note: since we use bit-masking to select table elements, the skip
1286 * table size MUST be a power of 2, and so the mask must be 2^N-1.
1287 */
1300 else
1304 /*
1305 * Initialize the skip table. We set all elements to the needle
1306 * length, since this is the correct skip distance for any character
1307 * not found in the needle.
1308 */
1312 /*
1313 * Now examine the needle. For each character except the last one,
1314 * set the corresponding table element to the appropriate skip
1315 * distance. Note that when two characters share the same skip table
1316 * entry, the one later in the needle must determine the skip
1317 * distance.
1318 */
1323 }
1324 }
1326 /*
1327 * Advance to the next match, starting from the end of the previous match
1328 * (or the beginning of the string, on first call). Returns true if a match
1329 * is found.
1330 *
1331 * Note that this refuses to match an empty-string needle. Most callers
1332 * will have handled that case specially and we'll never see it here.
1333 */
1334 static bool
1336 {
1344 /* Start from the point right after the previous match. */
1347 else
1350 retry:
1356 /*
1357 * Found a match for the byte sequence. If this is a multibyte encoding,
1358 * where one character's byte sequence can appear inside a longer
1359 * multi-byte character, we need to verify that the match was at a
1360 * character boundary, not in the middle of a multi-byte character.
1361 */
1363 {
1364 /* Walk one character at a time, until we reach the match. */
1366 /* the search should never move backwards. */
1370 {
1371 /* step to next character. */
1375 /*
1376 * If we stepped over the match's start position, then it was a
1377 * false positive, where the byte sequence appeared in the middle
1378 * of a multi-byte character. Skip it, and continue the search at
1379 * the next character boundary.
1380 */
1382 {
1385 }
1386 }
1387 }
1391 }
1393 /*
1394 * Subroutine of text_position_next(). This searches for the raw byte
1395 * sequence, ignoring any multi-byte encoding issues. Returns the first
1396 * match starting at 'start_ptr', or NULL if no match is found.
1397 */
1400 {
1412 {
1413 /* No point in using B-M-H for a one-character needle */
1418 {
1421 hptr++;
1422 }
1423 }
1424 else
1425 {
1428 /* Start at startpos plus the length of the needle */
1431 {
1432 /* Match the needle scanning *backward* */
1439 {
1440 /* Matched it all? If so, return 1-based position */
1444 }
1446 /*
1447 * No match, so use the haystack char at hptr to decide how far to
1448 * advance. If the needle had any occurrence of that character
1449 * (or more precisely, one sharing the same skiptable entry)
1450 * before its last character, then we advance far enough to align
1451 * the last such needle character with that haystack position.
1452 * Otherwise we can advance by the whole needle length.
1453 */
1455 }
1456 }
1459 }
1461 /*
1462 * Return a pointer to the current match.
1463 *
1464 * The returned pointer points into the original haystack string.
1465 */
1468 {
1470 }
1472 /*
1473 * Return the offset of the current match.
1474 *
1475 * The offset is in characters, 1-based.
1476 */
1477 static int
1479 {
1480 /* Convert the byte position to char position. */
1485 }
1487 /*
1488 * Reset search state to the initial state installed by text_position_setup.
1489 *
1490 * The next call to text_position_next will search from the beginning
1491 * of the string.
1492 */
1493 static void
1495 {
1499 }
1501 static void
1503 {
1504 /* no cleanup needed */
1505 }
1508 static void
1510 {
1512 {
1513 /*
1514 * This typically means that the parser could not resolve a conflict
1515 * of implicit collations, so report it that way.
1516 */
1521 }
1522 }
1524 /*
1525 * varstr_cmp()
1526 *
1527 * Comparison function for text strings with given lengths, using the
1528 * appropriate locale. Returns an integer less than, equal to, or greater than
1529 * zero, indicating whether arg1 is less than, equal to, or greater than arg2.
1530 *
1531 * Note: many functions that depend on this are marked leakproof; therefore,
1532 * avoid reporting the actual contents of the input when throwing errors.
1533 * All errors herein should be things that can't happen except on corrupt
1534 * data, anyway; otherwise we will have trouble with indexing strings that
1535 * would cause them.
1536 */
1537 int
1539 {
1541 pg_locale_t mylocale;
1548 {
1552 }
1553 else
1554 {
1555 /*
1556 * memcmp() can't tell us which of two unequal strings sorts first,
1557 * but it's a cheap way to tell if they're equal. Testing shows that
1558 * memcmp() followed by strcoll() is only trivially slower than
1559 * strcoll() by itself, so we don't lose much if this doesn't work out
1560 * very often, and if it does - for example, because there are many
1561 * equal strings in the input - then we win big by avoiding expensive
1562 * collation-aware comparisons.
1563 */
1569 /* Break tie if necessary. */
1571 {
1575 }
1576 }
1579 }
1581 /* text_cmp()
1582 * Internal comparison function for text strings.
1583 * Returns -1, 0 or 1
1584 */
1585 static int
1587 {
1591 len2;
1600 }
1602 /*
1603 * Comparison functions for text strings.
1604 *
1605 * Note: btree indexes need these routines not to leak memory; therefore,
1606 * be careful to free working copies of toasted datums. Most places don't
1607 * need to be so careful.
1608 */
1610 Datum
1612 {
1622 {
1625 Size len1,
1626 len2;
1628 /*
1629 * Since we only care about equality or not-equality, we can avoid all
1630 * the expense of strcoll() here, and just do bitwise comparison. In
1631 * fact, we don't even have to do a bitwise comparison if we can show
1632 * the lengths of the strings are unequal; which might save us from
1633 * having to detoast one or both values.
1634 */
1639 else
1640 {
1649 }
1650 }
1651 else
1652 {
1660 }
1663 }
1665 Datum
1667 {
1669 pg_locale_t mylocale;
1677 {
1680 Size len1,
1681 len2;
1683 /* See comment in texteq() */
1688 else
1689 {
1698 }
1699 }
1700 else
1701 {
1709 }
1712 }
1714 Datum
1716 {
1727 }
1729 Datum
1731 {
1742 }
1744 Datum
1746 {
1757 }
1759 Datum
1761 {
1772 }
1774 Datum
1776 {
1780 pg_locale_t mylocale;
1782 Size len1,
1783 len2;
1798 else
1799 {
1808 }
1811 }
1813 Datum
1815 {
1818 int32 result;
1826 }
1828 Datum
1830 {
1833 MemoryContext oldcontext;
1837 /* Use generic string SortSupport */
1843 }
1845 /*
1846 * Generic sortsupport interface for character type's operator classes.
1847 * Includes locale support, and support for BpChar semantics (i.e. removing
1848 * trailing spaces before comparison).
1849 *
1850 * Relies on the assumption that text, VarChar, BpChar, and bytea all have the
1851 * same representation. Callers that always use the C collation (e.g.
1852 * non-collatable type callers like bytea) may have NUL bytes in their strings;
1853 * this will not work with any other collation, though.
1854 */
1855 void
1857 {
1861 pg_locale_t locale;
1867 /*
1868 * If possible, set ssup->comparator to a function which can be used to
1869 * directly compare two datums. If we can do this, we'll avoid the
1870 * overhead of a trip through the fmgr layer for every comparison, which
1871 * can be substantial.
1872 *
1873 * Most typically, we'll set the comparator to varlenafastcmp_locale,
1874 * which uses strcoll() to perform comparisons. We use that for the
1875 * BpChar case too, but type NAME uses namefastcmp_locale. However, if
1876 * LC_COLLATE = C, we can make things quite a bit faster with
1877 * varstrfastcmp_c, bpcharfastcmp_c, or namefastcmp_c, all of which use
1878 * memcmp() rather than strcoll().
1879 */
1881 {
1885 {
1887 /* Not supporting abbreviation with type NAME, for now */
1889 }
1890 else
1894 }
1895 else
1896 {
1897 /*
1898 * We use varlenafastcmp_locale except for type NAME.
1899 */
1901 {
1903 /* Not supporting abbreviation with type NAME, for now */
1905 }
1906 else
1909 /*
1910 * Unfortunately, it seems that abbreviation for non-C collations is
1911 * broken on many common platforms; see pg_strxfrm_enabled().
1912 *
1913 * Even apart from the risk of broken locales, it's possible that
1914 * there are platforms where the use of abbreviated keys should be
1915 * disabled at compile time. Having only 4 byte datums could make
1916 * worst-case performance drastically more likely, for example.
1917 * Moreover, macOS's strxfrm() implementation is known to not
1918 * effectively concentrate a significant amount of entropy from the
1919 * original string in earlier transformed blobs. It's possible that
1920 * other supported platforms are similarly encumbered. So, if we ever
1921 * get past disabling this categorically, we may still want or need to
1922 * disable it for particular platforms.
1923 */
1926 }
1928 /*
1929 * If we're using abbreviated keys, or if we're using a locale-aware
1930 * comparison, we need to initialize a VarStringSortSupport object. Both
1931 * cases will make use of the temporary buffers we initialize here for
1932 * scratch space (and to detect requirement for BpChar semantics from
1933 * caller), and the abbreviation case requires additional state.
1934 */
1936 {
1942 /* Start with invalid values */
1945 /* Initialize */
1949 else
1952 /*
1953 * To avoid somehow confusing a strxfrm() blob and an original string,
1954 * constantly keep track of the variety of data that buf1 and buf2
1955 * currently contain.
1956 *
1957 * Comparisons may be interleaved with conversion calls. Frequently,
1958 * conversions and comparisons are batched into two distinct phases,
1959 * but the correctness of caching cannot hinge upon this. For
1960 * comparison caching, buffer state is only trusted if cache_blob is
1961 * found set to false, whereas strxfrm() caching only trusts the state
1962 * when cache_blob is found set to true.
1963 *
1964 * Arbitrarily initialize cache_blob to true.
1965 */
1971 /*
1972 * If possible, plan to use the abbreviated keys optimization. The
1973 * core code may switch back to authoritative comparator should
1974 * abbreviation be aborted.
1975 */
1977 {
1985 }
1986 }
1987 }
1989 /*
1990 * sortsupport comparison func (for C locale case)
1991 */
1992 static int
1994 {
2000 len2,
2001 result;
2013 /* We can't afford to leak memory here. */
2020 }
2022 /*
2023 * sortsupport comparison func (for BpChar C locale case)
2024 *
2025 * BpChar outsources its sortsupport to this module. Specialization for the
2026 * varstr_sortsupport BpChar case, modeled on
2027 * internal_bpchar_pattern_compare().
2028 */
2029 static int
2031 {
2037 len2,
2038 result;
2050 /* We can't afford to leak memory here. */
2057 }
2059 /*
2060 * sortsupport comparison func (for NAME C locale case)
2061 */
2062 static int
2064 {
2069 }
2071 /*
2072 * sortsupport comparison func (for locale case with all varlena types)
2073 */
2074 static int
2076 {
2082 len2,
2083 result;
2093 /* We can't afford to leak memory here. */
2100 }
2102 /*
2103 * sortsupport comparison func (for locale case with NAME type)
2104 */
2105 static int
2107 {
2113 ssup);
2114 }
2116 /*
2117 * sortsupport comparison func for locale cases
2118 */
2119 static int
2121 {
2126 /* Fast pre-check for equality, as discussed in varstr_cmp() */
2128 {
2129 /*
2130 * No change in buf1 or buf2 contents, so avoid changing last_len1 or
2131 * last_len2. Existing contents of buffers might still be used by
2132 * next call.
2133 *
2134 * It's fine to allow the comparison of BpChar padding bytes here,
2135 * even though that implies that the memcmp() will usually be
2136 * performed for BpChar callers (though multibyte characters could
2137 * still prevent that from occurring). The memcmp() is still very
2138 * cheap, and BpChar's funny semantics have us remove trailing spaces
2139 * (not limited to padding), so we need make no distinction between
2140 * padding space characters and "real" space characters.
2141 */
2143 }
2146 {
2147 /* Get true number of bytes, ignoring trailing spaces */
2150 }
2153 {
2156 }
2158 {
2161 }
2163 /*
2164 * We're likely to be asked to compare the same strings repeatedly, and
2165 * memcmp() is so much cheaper than strcoll() that it pays to try to cache
2166 * comparisons, even though in general there is no reason to think that
2167 * that will work out (every string datum may be unique). Caching does
2168 * not slow things down measurably when it doesn't work out, and can speed
2169 * things up by rather a lot when it does. In part, this is because the
2170 * memcmp() compares data from cachelines that are needed in L1 cache even
2171 * when the last comparison's result cannot be reused.
2172 */
2175 {
2180 }
2182 /*
2183 * If we're comparing the same two strings as last time, we can return the
2184 * same answer without calling strcoll() again. This is more likely than
2185 * it seems (at least with moderate to low cardinality sets), because
2186 * quicksort compares the same pivot against many values.
2187 */
2189 {
2193 }
2195 {
2196 /* Use result cached following last actual strcoll() call */
2198 }
2202 /* Break tie if necessary. */
2206 /* Cache result, perhaps saving an expensive strcoll() call next time */
2210 }
2212 /*
2213 * Conversion routine for sortsupport. Converts original to abbreviated key
2214 * representation. Our encoding strategy is simple -- pack the first 8 bytes
2215 * of a strxfrm() blob into a Datum (on little-endian machines, the 8 bytes are
2216 * stored in reverse order), and treat it as an unsigned integer. When the "C"
2217 * locale is used, or in case of bytea, just memcpy() from original instead.
2218 */
2219 static Datum
2221 {
2227 /* working state */
2228 Datum res;
2231 uint32 hash;
2234 /* memset(), so any non-overwritten bytes are NUL */
2238 /* Get number of bytes, ignoring trailing spaces */
2242 /*
2243 * If we're using the C collation, use memcpy(), rather than strxfrm(), to
2244 * abbreviate keys. The full comparator for the C locale is always
2245 * memcmp(). It would be incorrect to allow bytea callers (callers that
2246 * always force the C collation -- bytea isn't a collatable type, but this
2247 * approach is convenient) to use strxfrm(). This is because bytea
2248 * strings may contain NUL bytes. Besides, this should be faster, too.
2249 *
2250 * More generally, it's okay that bytea callers can have NUL bytes in
2251 * strings because abbreviated cmp need not make a distinction between
2252 * terminating NUL bytes, and NUL bytes representing actual NULs in the
2253 * authoritative representation. Hopefully a comparison at or past one
2254 * abbreviated key's terminating NUL byte will resolve the comparison
2255 * without consulting the authoritative representation; specifically, some
2256 * later non-NUL byte in the longer string can resolve the comparison
2257 * against a subsequent terminating NUL in the shorter string. There will
2258 * usually be what is effectively a "length-wise" resolution there and
2259 * then.
2260 *
2261 * If that doesn't work out -- if all bytes in the longer string
2262 * positioned at or past the offset of the smaller string's (first)
2263 * terminating NUL are actually representative of NUL bytes in the
2264 * authoritative binary string (perhaps with some *terminating* NUL bytes
2265 * towards the end of the longer string iff it happens to still be small)
2266 * -- then an authoritative tie-breaker will happen, and do the right
2267 * thing: explicitly consider string length.
2268 */
2271 else
2272 {
2273 Size bsize;
2275 /*
2276 * We're not using the C collation, so fall back on strxfrm or ICU
2277 * analogs.
2278 */
2280 /* By convention, we use buffer 1 to store and NUL-terminate */
2282 {
2285 }
2287 /* Might be able to reuse strxfrm() blob from last call */
2290 {
2292 /* No change affecting cardinality, so no hashing required */
2294 }
2298 /*
2299 * pg_strxfrm() and pg_strxfrm_prefix expect NUL-terminated strings.
2300 */
2305 {
2307 {
2311 }
2316 }
2317 else
2318 {
2319 /*
2320 * Loop: Call pg_strxfrm(), possibly enlarge buffer, and try
2321 * again. The pg_strxfrm() function leaves the result buffer
2322 * content undefined if the result did not fit, so we need to
2323 * retry until everything fits, even though we only need the first
2324 * few bytes in the end.
2325 */
2327 {
2335 /*
2336 * Grow buffer and retry.
2337 */
2341 }
2342 }
2344 /*
2345 * Every Datum byte is always compared. This is safe because the
2346 * strxfrm() blob is itself NUL terminated, leaving no danger of
2347 * misinterpreting any NUL bytes not intended to be interpreted as
2348 * logically representing termination.
2349 *
2350 * (Actually, even if there were NUL bytes in the blob it would be
2351 * okay. See remarks on bytea case above.)
2352 */
2354 }
2356 /*
2357 * Maintain approximate cardinality of both abbreviated keys and original,
2358 * authoritative keys using HyperLogLog. Used as cheap insurance against
2359 * the worst case, where we do many string transformations for no saving
2360 * in full strcoll()-based comparisons. These statistics are used by
2361 * varstr_abbrev_abort().
2362 *
2363 * First, Hash key proper, or a significant fraction of it. Mix in length
2364 * in order to compensate for cases where differences are past
2365 * PG_CACHE_LINE_SIZE bytes, so as to limit the overhead of hashing.
2366 */
2375 /* Hash abbreviated key */
2376 #if SIZEOF_DATUM == 8
2377 {
2378 uint32 lohalf,
2379 hihalf;
2384 }
2387 #endif
2391 /* Cache result, perhaps saving an expensive strxfrm() call next time */
2393 done:
2395 /*
2396 * Byteswap on little-endian machines.
2397 *
2398 * This is needed so that ssup_datum_unsigned_cmp() (an unsigned integer
2399 * 3-way comparator) works correctly on all platforms. If we didn't do
2400 * this, the comparator would have to call memcmp() with a pair of
2401 * pointers to the first byte of each abbreviated key, which is slower.
2402 */
2405 /* Don't leak memory here */
2410 }
2412 /*
2413 * Callback for estimating effectiveness of abbreviated key optimization, using
2414 * heuristic rules. Returns value indicating if the abbreviation optimization
2415 * should be aborted, based on its projected effectiveness.
2416 */
2417 static bool
2419 {
2422 key_distinct;
2426 /* Have a little patience */
2433 /*
2434 * Clamp cardinality estimates to at least one distinct value. While
2435 * NULLs are generally disregarded, if only NULL values were seen so far,
2436 * that might misrepresent costs if we failed to clamp.
2437 */
2444 /*
2445 * In the worst case all abbreviated keys are identical, while at the same
2446 * time there are differences within full key strings not captured in
2447 * abbreviations.
2448 */
2450 {
2457 }
2459 /*
2460 * If the number of distinct abbreviated keys approximately matches the
2461 * number of distinct authoritative original keys, that's reason enough to
2462 * proceed. We can win even with a very low cardinality set if most
2463 * tie-breakers only memcmp(). This is by far the most important
2464 * consideration.
2465 *
2466 * While comparisons that are resolved at the abbreviated key level are
2467 * considerably cheaper than tie-breakers resolved with memcmp(), both of
2468 * those two outcomes are so much cheaper than a full strcoll() once
2469 * sorting is underway that it doesn't seem worth it to weigh abbreviated
2470 * cardinality against the overall size of the set in order to more
2471 * accurately model costs. Assume that an abbreviated comparison, and an
2472 * abbreviated comparison with a cheap memcmp()-based authoritative
2473 * resolution are equivalent.
2474 */
2476 {
2477 /*
2478 * When we have exceeded 10,000 tuples, decay required cardinality
2479 * aggressively for next call.
2480 *
2481 * This is useful because the number of comparisons required on
2482 * average increases at a linearithmic rate, and at roughly 10,000
2483 * tuples that factor will start to dominate over the linear costs of
2484 * string transformation (this is a conservative estimate). The decay
2485 * rate is chosen to be a little less aggressive than halving -- which
2486 * (since we're called at points at which memtupcount has doubled)
2487 * would never see the cost model actually abort past the first call
2488 * following a decay. This decay rate is mostly a precaution against
2489 * a sudden, violent swing in how well abbreviated cardinality tracks
2490 * full key cardinality. The decay also serves to prevent a marginal
2491 * case from being aborted too late, when too much has already been
2492 * invested in string transformation.
2493 *
2494 * It's possible for sets of several million distinct strings with
2495 * mere tens of thousands of distinct abbreviated keys to still
2496 * benefit very significantly. This will generally occur provided
2497 * each abbreviated key is a proxy for a roughly uniform number of the
2498 * set's full keys. If it isn't so, we hope to catch that early and
2499 * abort. If it isn't caught early, by the time the problem is
2500 * apparent it's probably not worth aborting.
2501 */
2506 }
2508 /*
2509 * Abort abbreviation strategy.
2510 *
2511 * The worst case, where all abbreviated keys are identical while all
2512 * original strings differ will typically only see a regression of about
2513 * 10% in execution time for small to medium sized lists of strings.
2514 * Whereas on modern CPUs where cache stalls are the dominant cost, we can
2515 * often expect very large improvements, particularly with sets of strings
2516 * of moderately high to high abbreviated cardinality. There is little to
2517 * lose but much to gain, which our strategy reflects.
2518 */
2525 }
2527 /*
2528 * Generic equalimage support function for character type's operator classes.
2529 * Disables the use of deduplication with nondeterministic collations.
2530 */
2531 Datum
2533 {
2534 /* Oid opcintype = PG_GETARG_OID(0); */
2536 pg_locale_t locale;
2543 }
2545 Datum
2547 {
2555 }
2557 Datum
2559 {
2567 }
2570 /*
2571 * Cross-type comparison functions for types text and name.
2572 */
2574 Datum
2576 {
2589 else
2597 }
2599 Datum
2601 {
2614 else
2622 }
2624 Datum
2626 {
2639 else
2647 }
2649 Datum
2651 {
2664 else
2672 }
2674 Datum
2676 {
2679 int32 result;
2688 }
2690 Datum
2692 {
2695 int32 result;
2704 }
2706 #define CmpCall(cmpfunc) \
2707 DatumGetInt32(DirectFunctionCall2Coll(cmpfunc, \
2708 PG_GET_COLLATION(), \
2709 PG_GETARG_DATUM(0), \
2710 PG_GETARG_DATUM(1)))
2712 Datum
2714 {
2716 }
2718 Datum
2720 {
2722 }
2724 Datum
2726 {
2728 }
2730 Datum
2732 {
2734 }
2736 Datum
2738 {
2740 }
2742 Datum
2744 {
2746 }
2748 Datum
2750 {
2752 }
2754 Datum
2756 {
2758 }
2760 #undef CmpCall
2763 /*
2764 * The following operators support character-by-character comparison
2765 * of text datums, to allow building indexes suitable for LIKE clauses.
2766 * Note that the regular texteq/textne comparison operators, and regular
2767 * support functions 1 and 2 with "C" collation are assumed to be
2768 * compatible with these!
2769 */
2771 static int
2773 {
2776 len2;
2788 else
2790 }
2793 Datum
2795 {
2806 }
2809 Datum
2811 {
2822 }
2825 Datum
2827 {
2838 }
2841 Datum
2843 {
2854 }
2857 Datum
2859 {
2870 }
2873 Datum
2875 {
2877 MemoryContext oldcontext;
2881 /* Use generic string SortSupport, forcing "C" collation */
2887 }
2890 /*-------------------------------------------------------------
2891 * byteaoctetlen
2892 *
2893 * get the number of bytes contained in an instance of type 'bytea'
2894 *-------------------------------------------------------------
2895 */
2896 Datum
2898 {
2901 /* We need not detoast the input at all */
2903 }
2905 /*
2906 * byteacat -
2907 * takes two bytea* and returns a bytea* that is the concatenation of
2908 * the two.
2909 *
2910 * Cloned from textcat and modified as required.
2911 */
2912 Datum
2914 {
2919 }
2921 /*
2922 * bytea_catenate
2923 * Guts of byteacat(), broken out so it can be used by other functions
2924 *
2925 * Arguments can be in short-header form, but not compressed or out-of-line
2926 */
2929 {
2932 len2,
2933 len;
2939 /* paranoia ... probably should throw error instead? */
2948 /* Set size of result string... */
2951 /* Fill data field of result string... */
2959 }
2961 #define PG_STR_GET_BYTEA(str_) \
2962 DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))
2964 /*
2965 * bytea_substr()
2966 * Return a substring starting at the specified position.
2967 * Cloned from text_substr and modified as required.
2968 *
2969 * Input:
2970 * - string
2971 * - starting position (is one-based)
2972 * - string length (optional)
2973 *
2974 * If the starting position is zero or less, then return from the start of the string
2975 * adjusting the length to be consistent with the "negative start" per SQL.
2976 * If the length is less than zero, an ERROR is thrown. If no third argument
2977 * (length) is provided, the length to the end of the string is assumed.
2978 */
2979 Datum
2981 {
2986 }
2988 /*
2989 * bytea_substr_no_len -
2990 * Wrapper to avoid opr_sanity failure due to
2991 * one function accepting a different number of args.
2992 */
2993 Datum
2995 {
3000 }
3007 {
3012 /*
3013 * The logic here should generally match text_substring().
3014 */
3018 {
3019 /*
3020 * Not passed a length - DatumGetByteaPSlice() grabs everything to the
3021 * end of the string if we pass it a negative value for length.
3022 */
3024 }
3026 {
3027 /* SQL99 says to throw an error for E < S, i.e., negative length */
3032 }
3034 {
3035 /*
3036 * L could be large enough for S + L to overflow, in which case the
3037 * substring must run to end of string.
3038 */
3040 }
3041 else
3042 {
3043 /*
3044 * A zero or negative value for the end position can happen if the
3045 * start was negative or one. SQL99 says to return a zero-length
3046 * string.
3047 */
3052 }
3054 /*
3055 * If the start position is past the end of the string, SQL99 says to
3056 * return a zero-length string -- DatumGetByteaPSlice() will do that for
3057 * us. We need only convert S1 to zero-based starting position.
3058 */
3060 }
3062 /*
3063 * byteaoverlay
3064 * Replace specified substring of first string with second
3065 *
3066 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
3067 * This code is a direct implementation of what the standard says.
3068 */
3069 Datum
3071 {
3078 }
3080 Datum
3082 {
3090 }
3094 {
3100 /*
3101 * Check for possible integer-overflow cases. For negative sp, throw a
3102 * "substring length" error because that's what should be expected
3103 * according to the spec's definition of OVERLAY().
3104 */
3120 }
3122 /*
3123 * bit_count
3124 */
3125 Datum
3127 {
3131 }
3133 /*
3134 * byteapos -
3135 * Return the position of the specified substring.
3136 * Implements the SQL POSITION() function.
3137 * Cloned from textpos and modified as required.
3138 */
3139 Datum
3141 {
3146 p;
3148 len2;
3164 {
3166 {
3169 };
3170 p1++;
3171 };
3174 }
3176 /*-------------------------------------------------------------
3177 * byteaGetByte
3178 *
3179 * this routine treats "bytea" as an array of bytes.
3180 * It returns the Nth byte (a number between 0 and 255).
3181 *-------------------------------------------------------------
3182 */
3183 Datum
3185 {
3202 }
3204 /*-------------------------------------------------------------
3205 * byteaGetBit
3206 *
3207 * This routine treats a "bytea" type like an array of bits.
3208 * It returns the value of the Nth bit (0 or 1).
3209 *
3210 *-------------------------------------------------------------
3211 */
3212 Datum
3214 {
3218 bitNo;
3230 /* n/8 is now known < len, so safe to cast to int */
3238 else
3240 }
3242 /*-------------------------------------------------------------
3243 * byteaSetByte
3244 *
3245 * Given an instance of type 'bytea' creates a new one with
3246 * the Nth byte set to the given value.
3247 *
3248 *-------------------------------------------------------------
3249 */
3250 Datum
3252 {
3266 /*
3267 * Now set the byte.
3268 */
3272 }
3274 /*-------------------------------------------------------------
3275 * byteaSetBit
3276 *
3277 * Given an instance of type 'bytea' creates a new one with
3278 * the Nth bit set to the given value.
3279 *
3280 *-------------------------------------------------------------
3281 */
3282 Datum
3284 {
3290 newByte;
3292 bitNo;
3302 /* n/8 is now known < len, so safe to cast to int */
3306 /*
3307 * sanity check!
3308 */
3314 /*
3315 * Update the byte.
3316 */
3321 else
3327 }
3330 /* text_name()
3331 * Converts a text type to a Name type.
3332 */
3333 Datum
3335 {
3337 Name result;
3342 /* Truncate oversize input */
3346 /* We use palloc0 here to ensure result is zero-padded */
3351 }
3353 /* name_text()
3354 * Converts a Name type to a text type.
3355 */
3356 Datum
3358 {
3362 }
3365 /*
3366 * textToQualifiedNameList - convert a text object to list of names
3367 *
3368 * This implements the input parsing needed by nextval() and other
3369 * functions that take a text parameter representing a qualified name.
3370 * We split the name at dots, downcase if not double-quoted, and
3371 * truncate names if they're too long.
3372 */
3373 List *
3375 {
3381 /* Convert to C string (handles possible detoasting). */
3382 /* Note we rely on being able to modify rawname below. */
3396 {
3400 }
3406 }
3408 /*
3409 * SplitIdentifierString --- parse a string containing identifiers
3410 *
3411 * This is the guts of textToQualifiedNameList, and is exported for use in
3412 * other situations such as parsing GUC variables. In the GUC case, it's
3413 * important to avoid memory leaks, so the API is designed to minimize the
3414 * amount of stuff that needs to be allocated and freed.
3415 *
3416 * Inputs:
3417 * rawstring: the input string; must be overwritable! On return, it's
3418 * been modified to contain the separated identifiers.
3419 * separator: the separator punctuation expected between identifiers
3420 * (typically '.' or ','). Whitespace may also appear around
3421 * identifiers.
3422 * Outputs:
3423 * namelist: filled with a palloc'd list of pointers to identifiers within
3424 * rawstring. Caller should list_free() this even on error return.
3425 *
3426 * Returns true if okay, false if there is a syntax error in the string.
3427 *
3428 * Note that an empty string is considered okay here, though not in
3429 * textToQualifiedNameList.
3430 */
3431 bool
3434 {
3446 /* At the top of the loop, we are at start of a new identifier. */
3447 do
3448 {
3453 {
3454 /* Quoted name --- collapse quote-quote pairs, no downcasing */
3457 {
3463 /* Collapse adjacent quotes into one quote, and look again */
3466 }
3467 /* endp now points at the terminating quote */
3469 }
3470 else
3471 {
3472 /* Unquoted name --- extends to separator or whitespace */
3479 nextp++;
3484 /*
3485 * Downcase the identifier, using same code as main lexer does.
3486 *
3487 * XXX because we want to overwrite the input in-place, we cannot
3488 * support a downcasing transformation that increases the string
3489 * length. This is not a problem given the current implementation
3490 * of downcase_truncate_identifier, but we'll probably have to do
3491 * something about this someday.
3492 */
3498 }
3504 {
3505 nextp++;
3508 /* we expect another name, so done remains false */
3509 }
3512 else
3515 /* Now safe to overwrite separator with a null */
3518 /* Truncate name if it's overlength */
3521 /*
3522 * Finished isolating current name --- add it to list
3523 */
3526 /* Loop back if we didn't reach end of string */
3530 }
3533 /*
3534 * SplitDirectoriesString --- parse a string containing file/directory names
3535 *
3536 * This works fine on file names too; the function name is historical.
3537 *
3538 * This is similar to SplitIdentifierString, except that the parsing
3539 * rules are meant to handle pathnames instead of identifiers: there is
3540 * no downcasing, embedded spaces are allowed, the max length is MAXPGPATH-1,
3541 * and we apply canonicalize_path() to each extracted string. Because of the
3542 * last, the returned strings are separately palloc'd rather than being
3543 * pointers into rawstring --- but we still scribble on rawstring.
3544 *
3545 * Inputs:
3546 * rawstring: the input string; must be modifiable!
3547 * separator: the separator punctuation expected between directories
3548 * (typically ',' or ';'). Whitespace may also appear around
3549 * directories.
3550 * Outputs:
3551 * namelist: filled with a palloc'd list of directory names.
3552 * Caller should list_free_deep() this even on error return.
3553 *
3554 * Returns true if okay, false if there is a syntax error in the string.
3555 *
3556 * Note that an empty string is considered okay here.
3557 */
3558 bool
3561 {
3573 /* At the top of the loop, we are at start of a new directory. */
3574 do
3575 {
3580 {
3581 /* Quoted name --- collapse quote-quote pairs */
3584 {
3590 /* Collapse adjacent quotes into one quote, and look again */
3593 }
3594 /* endp now points at the terminating quote */
3596 }
3597 else
3598 {
3599 /* Unquoted name --- extends to separator or end of string */
3602 {
3603 /* trailing whitespace should not be included in name */
3606 nextp++;
3607 }
3610 }
3616 {
3617 nextp++;
3620 /* we expect another name, so done remains false */
3621 }
3624 else
3627 /* Now safe to overwrite separator with a null */
3630 /* Truncate path if it's overlength */
3634 /*
3635 * Finished isolating current name --- add it to list
3636 */
3641 /* Loop back if we didn't reach end of string */
3645 }
3648 /*
3649 * SplitGUCList --- parse a string containing identifiers or file names
3650 *
3651 * This is used to split the value of a GUC_LIST_QUOTE GUC variable, without
3652 * presuming whether the elements will be taken as identifiers or file names.
3653 * We assume the input has already been through flatten_set_variable_args(),
3654 * so that we need never downcase (if appropriate, that was done already).
3655 * Nor do we ever truncate, since we don't know the correct max length.
3656 * We disallow embedded whitespace for simplicity (it shouldn't matter,
3657 * because any embedded whitespace should have led to double-quoting).
3658 * Otherwise the API is identical to SplitIdentifierString.
3659 *
3660 * XXX it's annoying to have so many copies of this string-splitting logic.
3661 * However, it's not clear that having one function with a bunch of option
3662 * flags would be much better.
3663 *
3664 * XXX there is a version of this function in src/bin/pg_dump/dumputils.c.
3665 * Be sure to update that if you have to change this.
3666 *
3667 * Inputs:
3668 * rawstring: the input string; must be overwritable! On return, it's
3669 * been modified to contain the separated identifiers.
3670 * separator: the separator punctuation expected between identifiers
3671 * (typically '.' or ','). Whitespace may also appear around
3672 * identifiers.
3673 * Outputs:
3674 * namelist: filled with a palloc'd list of pointers to identifiers within
3675 * rawstring. Caller should list_free() this even on error return.
3676 *
3677 * Returns true if okay, false if there is a syntax error in the string.
3678 */
3679 bool
3682 {
3694 /* At the top of the loop, we are at start of a new identifier. */
3695 do
3696 {
3701 {
3702 /* Quoted name --- collapse quote-quote pairs */
3705 {
3711 /* Collapse adjacent quotes into one quote, and look again */
3714 }
3715 /* endp now points at the terminating quote */
3717 }
3718 else
3719 {
3720 /* Unquoted name --- extends to separator or whitespace */
3724 nextp++;
3728 }
3734 {
3735 nextp++;
3738 /* we expect another name, so done remains false */
3739 }
3742 else
3745 /* Now safe to overwrite separator with a null */
3748 /*
3749 * Finished isolating current name --- add it to list
3750 */
3753 /* Loop back if we didn't reach end of string */
3757 }
3760 /*****************************************************************************
3761 * Comparison Functions used for bytea
3762 *
3763 * Note: btree indexes need these routines not to leak memory; therefore,
3764 * be careful to free working copies of toasted datums. Most places don't
3765 * need to be so careful.
3766 *****************************************************************************/
3768 Datum
3770 {
3774 Size len1,
3775 len2;
3777 /*
3778 * We can use a fast path for unequal lengths, which might save us from
3779 * having to detoast one or both values.
3780 */
3785 else
3786 {
3795 }
3798 }
3800 Datum
3802 {
3806 Size len1,
3807 len2;
3809 /*
3810 * We can use a fast path for unequal lengths, which might save us from
3811 * having to detoast one or both values.
3812 */
3817 else
3818 {
3827 }
3830 }
3832 Datum
3834 {
3838 len2;
3850 }
3852 Datum
3854 {
3858 len2;
3870 }
3872 Datum
3874 {
3878 len2;
3890 }
3892 Datum
3894 {
3898 len2;
3910 }
3912 Datum
3914 {
3918 len2;
3932 }
3934 Datum
3936 {
3941 len2;
3951 }
3953 Datum
3955 {
3960 len2;
3970 }
3972 Datum
3974 {
3976 MemoryContext oldcontext;
3980 /* Use generic string SortSupport, forcing "C" collation */
3986 }
3988 /*
3989 * appendStringInfoText
3990 *
3991 * Append a text to str.
3992 * Like appendStringInfoString(str, text_to_cstring(t)) but faster.
3993 */
3994 static void
3996 {
3998 }
4000 /*
4001 * replace_text
4002 * replace all occurrences of 'old_sub_str' in 'orig_str'
4003 * with 'new_sub_str' to form 'new_str'
4004 *
4005 * returns 'orig_str' if 'old_sub_str' == '' or 'orig_str' == ''
4006 * otherwise returns 'new_str'
4007 */
4008 Datum
4010 {
4016 TextPositionState state;
4021 StringInfoData str;
4027 /* Return unmodified source string if empty source or pattern */
4029 {
4031 }
4037 /* When the from_sub_text is not found, there is nothing to do. */
4039 {
4042 }
4048 do
4049 {
4052 /* copy the data skipped over by last text_position_next() */
4063 }
4066 /* copy trailing data */
4076 }
4078 /*
4079 * check_replace_text_has_escape
4080 *
4081 * Returns 0 if text contains no backslashes that need processing.
4082 * Returns 1 if text contains backslashes, but not regexp submatch specifiers.
4083 * Returns 2 if text contains regexp submatch specifiers (\1 .. \9).
4084 */
4085 static int
4087 {
4093 {
4094 /* Find next escape char, if any. */
4098 p++;
4099 /* Note: a backslash at the end doesn't require extra processing. */
4101 {
4105 p++;
4106 }
4107 }
4109 }
4111 /*
4112 * appendStringInfoRegexpSubstr
4113 *
4114 * Append replace_text to str, substituting regexp back references for
4115 * \n escapes. start_ptr is the start of the match in the source string,
4116 * at logical character position data_pos.
4117 */
4118 static void
4122 {
4127 {
4132 /* Find next escape char, if any. */
4137 /* Copy the text we just scanned over, if any. */
4141 /* Done if at end of string, else advance over escape char. */
4144 p++;
4147 {
4148 /* Escape at very end of input. Treat same as unexpected char */
4151 }
4154 {
4155 /* Use the back reference of regexp. */
4160 p++;
4161 }
4163 {
4164 /* Use the entire matched string. */
4167 p++;
4168 }
4170 {
4171 /* \\ means transfer one \ to output. */
4173 p++;
4175 }
4176 else
4177 {
4178 /*
4179 * If escape char is not followed by any expected char, just treat
4180 * it as ordinary data to copy. (XXX would it be better to throw
4181 * an error?)
4182 */
4185 }
4188 {
4189 /*
4190 * Copy the text that is back reference of regexp. Note so and eo
4191 * are counted in characters not bytes.
4192 */
4201 }
4202 }
4203 }
4205 /*
4206 * replace_text_regexp
4207 *
4208 * replace substring(s) in src_text that match pattern with replace_text.
4209 * The replace_text can contain backslash markers to substitute
4210 * (parts of) the matched text.
4211 *
4212 * cflags: regexp compile flags.
4213 * collation: collation to use.
4214 * search_start: the character (not byte) offset in src_text at which to
4215 * begin searching.
4216 * n: if 0, replace all matches; if > 0, replace only the N'th match.
4217 */
4218 text *
4223 {
4228 StringInfoData buf;
4239 /* Convert data string to wide characters. */
4243 /* Check whether replace_text has escapes, especially regexp submatches. */
4246 /* If no regexp submatches, we can use REG_NOSUB. */
4248 {
4250 /* Also tell pg_regexec we only want the whole-match location. */
4252 }
4254 /* Prepare the regexp. */
4257 /* start_ptr points to the data_pos'th character of src_text */
4262 {
4268 data,
4269 data_len,
4270 search_start,
4272 nmatch,
4273 pmatch,
4280 {
4287 }
4289 /*
4290 * Count matches, and decide whether to replace this match.
4291 */
4292 nmatches++;
4294 {
4295 /*
4296 * No, so advance search_start, but not start_ptr/data_pos. (Thus,
4297 * we treat the matched text as if it weren't matched, and copy it
4298 * to the output later.)
4299 */
4302 search_start++;
4304 }
4306 /*
4307 * Copy the text to the left of the match position. Note we are given
4308 * character not byte indexes.
4309 */
4311 {
4318 /*
4319 * Advance start_ptr over that text, to avoid multiple rescans of
4320 * it if the replace_text contains multiple back-references.
4321 */
4324 }
4326 /*
4327 * Copy the replace_text, processing escapes if any are present.
4328 */
4332 else
4335 /* Advance start_ptr and data_pos over the matched text. */
4340 /*
4341 * If we only want to replace one occurrence, we're done.
4342 */
4346 /*
4347 * Advance search position. Normally we start the next search at the
4348 * end of the previous match; but if the match was of zero length, we
4349 * have to advance by one character, or we'd just find the same match
4350 * again.
4351 */
4354 search_start++;
4355 }
4357 /*
4358 * Copy the text to the right of the last match.
4359 */
4361 {
4366 }
4373 }
4375 /*
4376 * split_part
4377 * parse input string based on provided field separator
4378 * return N'th item (1 based, negative counts from end)
4379 */
4380 Datum
4382 {
4388 TextPositionState state;
4394 /* field number is 1 based */
4403 /* return empty string for empty input string */
4407 /* handle empty field separator */
4409 {
4410 /* if first or last field, return input string, else empty string */
4413 else
4415 }
4417 /* find the first field separator */
4422 /* special case if fldsep not found at all */
4424 {
4426 /* if first or last field, return input string, else empty string */
4429 else
4431 }
4433 /*
4434 * take care of a negative field number (i.e. count from the right) by
4435 * converting to a positive field number; we need total number of fields
4436 */
4438 {
4439 /* we found a fldsep, so there are at least two fields */
4443 numfields++;
4445 /* special case of last field does not require an extra pass */
4447 {
4453 }
4455 /* else, convert fldnum to positive notation */
4458 /* if nonexistent field, return empty string */
4460 {
4463 }
4465 /* reset to pointing at first match, but now with positive fldnum */
4469 }
4471 /* identify bounds of first field */
4476 {
4477 /* identify bounds of next field */
4482 }
4487 {
4488 /* N'th field separator not found */
4489 /* if last field requested, return it, else empty string */
4491 {
4496 }
4497 else
4499 }
4500 else
4501 {
4502 /* non-last field requested */
4504 }
4507 }
4509 /*
4510 * Convenience function to return true when two text params are equal.
4511 */
4512 static bool
4514 {
4516 collid,
4519 }
4521 /*
4522 * text_to_array
4523 * parse input string and return text array of elements,
4524 * based on provided field separator
4525 */
4526 Datum
4528 {
4529 SplitTextOutputData tstate;
4531 /* For array output, tstate should start as all zeroes */
4541 CurrentMemoryContext));
4542 }
4544 /*
4545 * text_to_array_null
4546 * parse input string and return text array of elements,
4547 * based on provided field separator and null string
4548 *
4549 * This is a separate entry point only to prevent the regression tests from
4550 * complaining about different argument sets for the same internal function.
4551 */
4552 Datum
4554 {
4556 }
4558 /*
4559 * text_to_table
4560 * parse input string and return table of elements,
4561 * based on provided field separator
4562 */
4563 Datum
4565 {
4567 SplitTextOutputData tstate;
4577 }
4579 /*
4580 * text_to_table_null
4581 * parse input string and return table of elements,
4582 * based on provided field separator and null string
4583 *
4584 * This is a separate entry point only to prevent the regression tests from
4585 * complaining about different argument sets for the same internal function.
4586 */
4587 Datum
4589 {
4591 }
4593 /*
4594 * Common code for text_to_array, text_to_array_null, text_to_table
4595 * and text_to_table_null functions.
4596 *
4597 * These are not strict so we have to test for null inputs explicitly.
4598 * Returns false if result is to be null, else returns true.
4599 *
4600 * Note that if the result is valid but empty (zero elements), we return
4601 * without changing *tstate --- caller must handle that case, too.
4602 */
4603 static bool
4605 {
4615 /* when input string is NULL, then result is NULL too */
4621 /* fldsep can be NULL */
4624 else
4627 /* null_string can be NULL or omitted */
4630 else
4634 {
4635 /*
4636 * Normal case with non-null fldsep. Use the text_position machinery
4637 * to search for occurrences of fldsep.
4638 */
4639 TextPositionState state;
4644 /* return empty set for empty input string */
4648 /* empty field separator: return input string as a one-element set */
4650 {
4654 }
4661 {
4670 {
4671 /* fetch last field */
4674 }
4675 else
4676 {
4677 /* fetch non-last field */
4680 }
4682 /* build a temp text datum to pass to split_text_accum_result */
4685 /* stash away this field */
4695 }
4698 }
4699 else
4700 {
4701 /*
4702 * When fldsep is NULL, each character in the input string becomes a
4703 * separate element in the result set. The separator is effectively
4704 * the space between characters.
4705 */
4711 {
4716 /* build a temp text datum to pass to split_text_accum_result */
4719 /* stash away this field */
4727 }
4728 }
4731 }
4733 /*
4734 * Add text item to result set (table or array).
4735 *
4736 * This is also responsible for checking to see if the item matches
4737 * the null_string, in which case we should emit NULL instead.
4738 */
4739 static void
4743 Oid collation)
4744 {
4751 {
4760 values,
4761 nulls);
4762 }
4763 else
4764 {
4767 is_null,
4768 TEXTOID,
4769 CurrentMemoryContext);
4770 }
4771 }
4773 /*
4774 * array_to_text
4775 * concatenate Cstring representation of input array elements
4776 * using provided field separator
4777 */
4778 Datum
4780 {
4785 }
4787 /*
4788 * array_to_text_null
4789 * concatenate Cstring representation of input array elements
4790 * using provided field separator and null string
4791 *
4792 * This version is not strict so we have to test for null inputs explicitly.
4793 */
4794 Datum
4796 {
4801 /* returns NULL when first or second parameter is NULL */
4808 /* NULL null string is passed through as a null pointer */
4811 else
4815 }
4817 /*
4818 * common code for array_to_text and array_to_text_null functions
4819 */
4823 {
4827 ndims;
4828 Oid element_type;
4832 StringInfoData buf;
4844 /* if there are no elements, return an empty string */
4851 /*
4852 * We arrange to look up info about element type, including its output
4853 * conversion proc, only once per series of calls, assuming the element
4854 * type doesn't change underneath us.
4855 */
4858 {
4863 }
4866 {
4867 /*
4868 * Get info about element type, including its output conversion proc
4869 */
4877 }
4887 {
4888 Datum itemvalue;
4891 /* Get source element, checking for NULL */
4893 {
4894 /* if null_string is NULL, we just ignore null elements */
4896 {
4899 else
4902 }
4903 }
4904 else
4905 {
4912 else
4918 }
4920 /* advance bitmap pointer if any */
4922 {
4925 {
4926 bitmap++;
4928 }
4929 }
4930 }
4936 }
4938 /*
4939 * Workhorse for to_bin, to_oct, and to_hex. Note that base must be > 1 and <=
4940 * 16.
4941 */
4944 {
4947 /* We size the buffer for to_bin's longest possible return value. */
4955 do
4956 {
4962 }
4964 /*
4965 * Convert an integer to a string containing a base-2 (binary) representation
4966 * of the number.
4967 */
4968 Datum
4970 {
4974 }
4975 Datum
4977 {
4981 }
4983 /*
4984 * Convert an integer to a string containing a base-8 (oct) representation of
4985 * the number.
4986 */
4987 Datum
4989 {
4993 }
4994 Datum
4996 {
5000 }
5002 /*
5003 * Convert an integer to a string containing a base-16 (hex) representation of
5004 * the number.
5005 */
5006 Datum
5008 {
5012 }
5013 Datum
5015 {
5019 }
5021 /*
5022 * Return the size of a datum, possibly compressed
5023 *
5024 * Works on any data type
5025 */
5026 Datum
5028 {
5030 int32 result;
5033 /* On first call, get the input type's typlen, and save at *fn_extra */
5035 {
5036 /* Lookup the datatype of the supplied argument */
5046 }
5047 else
5051 {
5052 /* varlena type, possibly toasted */
5054 }
5056 {
5057 /* cstring */
5059 }
5060 else
5061 {
5062 /* ordinary fixed-width type */
5064 }
5067 }
5069 /*
5070 * Return the compression method stored in the compressed attribute. Return
5071 * NULL for non varlena type or uncompressed data.
5072 */
5073 Datum
5075 {
5078 ToastCompressionId cmid;
5080 /* On first call, get the input type's typlen, and save at *fn_extra */
5082 {
5083 /* Lookup the datatype of the supplied argument */
5093 }
5094 else
5100 /* get the compression method id stored in the compressed varlena */
5106 /* convert compression method id to compression method name */
5108 {
5117 }
5120 }
5122 /*
5123 * Return the chunk_id of the on-disk TOASTed value. Return NULL if the value
5124 * is un-TOASTed or not on-disk.
5125 */
5126 Datum
5128 {
5133 /* On first call, get the input type's typlen, and save at *fn_extra */
5135 {
5136 /* Lookup the datatype of the supplied argument */
5146 }
5147 else
5161 }
5163 /*
5164 * string_agg - Concatenates values and returns string.
5165 *
5166 * Syntax: string_agg(value text, delimiter text) RETURNS text
5167 *
5168 * Note: Any NULL values are ignored. The first-call delimiter isn't
5169 * actually used at all, and on subsequent calls the delimiter precedes
5170 * the associated value.
5171 */
5173 /* subroutine to initialize state */
5174 static StringInfo
5176 {
5177 StringInfo state;
5178 MemoryContext aggcontext;
5179 MemoryContext oldcontext;
5182 {
5183 /* cannot be called directly because of internal-type argument */
5185 }
5187 /*
5188 * Create state in aggregate context. It'll stay there across subsequent
5189 * calls.
5190 */
5196 }
5198 Datum
5200 {
5201 StringInfo state;
5205 /* Append the value unless null, preceding it with the delimiter. */
5207 {
5211 /*
5212 * You might think we can just throw away the first delimiter, however
5213 * we must keep it as we may be a parallel worker doing partial
5214 * aggregation building a state to send to the main process. We need
5215 * to keep the delimiter of every aggregation so that the combine
5216 * function can properly join up the strings of two separately
5217 * partially aggregated results. The first delimiter is only stripped
5218 * off in the final function. To know how much to strip off the front
5219 * of the string, we store the length of the first delimiter in the
5220 * StringInfo's cursor field, which we don't otherwise need here.
5221 */
5223 {
5226 }
5229 {
5235 }
5238 }
5240 /*
5241 * The transition type for string_agg() is declared to be "internal",
5242 * which is a pass-by-value type the same size as a pointer.
5243 */
5247 }
5249 /*
5250 * string_agg_combine
5251 * Aggregate combine function for string_agg(text) and string_agg(bytea)
5252 */
5253 Datum
5255 {
5256 StringInfo state1;
5257 StringInfo state2;
5258 MemoryContext agg_context;
5267 {
5268 /*
5269 * NULL state2 is easy, just return state1, which we know is already
5270 * in the agg_context
5271 */
5275 }
5278 {
5279 /* We must copy state2's data into the agg_context */
5280 MemoryContext old_context;
5287 }
5289 {
5290 /* Combine ... state1->cursor does not change in this case */
5292 }
5295 }
5297 /*
5298 * string_agg_serialize
5299 * Aggregate serialize function for string_agg(text) and string_agg(bytea)
5300 *
5301 * This is strict, so we need not handle NULL input
5302 */
5303 Datum
5305 {
5306 StringInfo state;
5307 StringInfoData buf;
5310 /* cannot be called directly because of internal-type argument */
5317 /* cursor */
5320 /* data */
5326 }
5328 /*
5329 * string_agg_deserialize
5330 * Aggregate deserial function for string_agg(text) and string_agg(bytea)
5331 *
5332 * This is strict, so we need not handle NULL input
5333 */
5334 Datum
5336 {
5338 StringInfo result;
5339 StringInfoData buf;
5343 /* cannot be called directly because of internal-type argument */
5348 /*
5349 * Initialize a StringInfo so that we can "receive" it using the standard
5350 * recv-function infrastructure.
5351 */
5357 /* cursor */
5360 /* data */
5368 }
5370 Datum
5372 {
5373 StringInfo state;
5375 /* cannot be called directly because of internal-type argument */
5381 {
5382 /* As per comment in transfn, strip data before the cursor position */
5385 }
5386 else
5388 }
5390 /*
5391 * Prepare cache with fmgr info for the output functions of the datatypes of
5392 * the arguments of a concat-like function, beginning with argument "argidx".
5393 * (Arguments before that will have corresponding slots in the resulting
5394 * FmgrInfo array, but we don't fill those slots.)
5395 */
5398 {
5402 /* We keep the info in fn_mcxt so it survives across calls */
5407 {
5408 Oid valtype;
5409 Oid typOutput;
5418 }
5423 }
5425 /*
5426 * Implementation of both concat() and concat_ws().
5427 *
5428 * sepstr is the separator string to place between values.
5429 * argidx identifies the first argument to concatenate (counting from zero);
5430 * note that this must be constant across any one series of calls.
5431 *
5432 * Returns NULL if result should be NULL, else text value.
5433 */
5436 FunctionCallInfo fcinfo)
5437 {
5439 StringInfoData str;
5444 /*
5445 * concat(VARIADIC some-array) is essentially equivalent to
5446 * array_to_text(), ie concat the array elements with the given separator.
5447 * So we just pass the case off to that code.
5448 */
5450 {
5453 /* Should have just the one argument */
5456 /* concat(VARIADIC NULL) is defined as NULL */
5460 /*
5461 * Non-null argument had better be an array. We assume that any call
5462 * context that could let get_fn_expr_variadic return true will have
5463 * checked that a VARIADIC-labeled parameter actually is an array. So
5464 * it should be okay to just Assert that it's an array rather than
5465 * doing a full-fledged error check.
5466 */
5469 /* OK, safe to fetch the array value */
5472 /*
5473 * And serialize the array. We tell array_to_text to ignore null
5474 * elements, which matches the behavior of the loop below.
5475 */
5477 }
5479 /* Normal case without explicit VARIADIC marker */
5482 /* Get output function info, building it if first time through */
5488 {
5490 {
5493 /* add separator if appropriate */
5496 else
5499 /* call the appropriate type output function, append the result */
5502 }
5503 }
5509 }
5511 /*
5512 * Concatenate all arguments. NULL arguments are ignored.
5513 */
5514 Datum
5516 {
5523 }
5525 /*
5526 * Concatenate all but first argument value with separators. The first
5527 * parameter is used as the separator. NULL arguments are ignored.
5528 */
5529 Datum
5531 {
5535 /* return NULL when separator is NULL */
5544 }
5546 /*
5547 * Return first n characters in the string. When n is negative,
5548 * return all but last |n| characters.
5549 */
5550 Datum
5552 {
5556 {
5565 }
5566 else
5568 }
5570 /*
5571 * Return last n characters in the string. When n is negative,
5572 * return all but first |n| characters.
5573 */
5574 Datum
5576 {
5585 else
5590 }
5592 /*
5593 * Return reversed string
5594 */
5595 Datum
5597 {
5610 {
5611 /* multibyte version */
5613 {
5620 }
5621 }
5622 else
5623 {
5624 /* single byte version */
5627 }
5630 }
5633 /*
5634 * Support macros for text_format()
5635 */
5638 #define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
5639 do { \
5640 if (++(ptr) >= (end_ptr)) \
5641 ereport(ERROR, \
5642 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
5645 } while (0)
5647 /*
5648 * Returns a formatted string
5649 */
5650 Datum
5652 {
5654 StringInfoData str;
5667 FmgrInfo typoutputfinfo;
5668 FmgrInfo typoutputinfo_width;
5670 /* When format string is null, immediately return null */
5674 /* If argument is marked VARIADIC, expand array into elements */
5676 {
5678 int16 elmlen;
5683 /* Should have just the one argument */
5686 /* If argument is NULL, we treat it as zero-length array */
5689 else
5690 {
5691 /*
5692 * Non-null argument had better be an array. We assume that any
5693 * call context that could let get_fn_expr_variadic return true
5694 * will have checked that a VARIADIC-labeled parameter actually is
5695 * an array. So it should be okay to just Assert that it's an
5696 * array rather than doing a full-fledged error check.
5697 */
5700 /* OK, safe to fetch the array value */
5703 /* Get info about array element type */
5708 /* Extract all array elements */
5711 }
5715 }
5716 else
5717 {
5718 /* Non-variadic case, we'll process the arguments individually */
5721 }
5723 /* Setup for main loop. */
5730 /* Scan format string, looking for conversion specifiers. */
5732 {
5737 Datum value;
5739 Oid typid;
5741 /*
5742 * If it's not the start of a conversion specifier, just copy it to
5743 * the output buffer.
5744 */
5746 {
5749 }
5753 /* Easy case: %% outputs a single % */
5755 {
5758 }
5760 /* Parse the optional portions of the format specifier */
5765 /*
5766 * Next we should see the main conversion specifier. Whether or not
5767 * an argument position was present, it's known that at least one
5768 * character remains in the string at this point. Experience suggests
5769 * that it's worth checking that that character is one of the expected
5770 * ones before we try to fetch arguments, so as to produce the least
5771 * confusing response to a mis-formatted specifier.
5772 */
5780 /* If indirect width was specified, get its value */
5782 {
5783 /* Collect the specified or next argument position */
5791 /* Get the value and type of the selected argument */
5793 {
5797 }
5798 else
5799 {
5803 }
5807 arg++;
5809 /* We can treat NULL width the same as zero */
5816 else
5817 {
5818 /* For less-usual datatypes, convert to text then to int */
5822 {
5823 Oid typoutputfunc;
5829 }
5833 /* pg_strtoint32 will complain about bad data or overflow */
5837 }
5838 }
5840 /* Collect the specified or next argument position */
5848 /* Get the value and type of the selected argument */
5850 {
5854 }
5855 else
5856 {
5860 }
5864 arg++;
5866 /*
5867 * Get the appropriate typOutput function, reusing previous one if
5868 * same type as previous argument. That's particularly useful in the
5869 * variadic-array case, but often saves work even for ordinary calls.
5870 */
5872 {
5873 Oid typoutputfunc;
5879 }
5881 /*
5882 * And now we can format the value.
5883 */
5885 {
5894 /* should not get here, because of previous check */
5901 }
5902 }
5904 /* Don't need deconstruct_array results anymore. */
5910 /* Generate results. */
5915 }
5917 /*
5918 * Parse contiguous digits as a decimal number.
5919 *
5920 * Returns true if some digits could be parsed.
5921 * The value is returned into *value, and *ptr is advanced to the next
5922 * character to be parsed.
5923 *
5924 * Note parsing invariant: at least one character is known available before
5925 * string end (end_ptr) at entry, and this is still true at exit.
5926 */
5927 static bool
5929 {
5935 {
5945 }
5951 }
5953 /*
5954 * Parse a format specifier (generally following the SUS printf spec).
5955 *
5956 * We have already advanced over the initial '%', and we are looking for
5957 * [argpos][flags][width]type (but the type character is not consumed here).
5958 *
5959 * Inputs are start_ptr (the position after '%') and end_ptr (string end + 1).
5960 * Output parameters:
5961 * argpos: argument position for value to be printed. -1 means unspecified.
5962 * widthpos: argument position for width. Zero means the argument position
5963 * was unspecified (ie, take the next arg) and -1 means no width
5964 * argument (width was omitted or specified as a constant).
5965 * flags: bitmask of flags.
5966 * width: directly-specified width value. Zero means the width was omitted
5967 * (note it's not necessary to distinguish this case from an explicit
5968 * zero width value).
5969 *
5970 * The function result is the next character position to be parsed, ie, the
5971 * location where the type character is/should be.
5972 *
5973 * Note parsing invariant: at least one character is known available before
5974 * string end (end_ptr) at entry, and this is still true at exit.
5975 */
5980 {
5984 /* set defaults for output parameters */
5990 /* try to identify first number */
5992 {
5994 {
5995 /* Must be just a width and a type, so we're done */
5998 }
5999 /* The number was argument position */
6001 /* Explicit 0 for argument index is immediately refused */
6007 }
6009 /* Handle flags (only minus is supported now) */
6011 {
6014 }
6017 {
6018 /* Handle indirect width */
6021 {
6022 /* number in this position must be closed by $ */
6027 /* The number was width argument position */
6029 /* Explicit 0 for argument index is immediately refused */
6035 }
6036 else
6038 }
6039 else
6040 {
6041 /* Check for direct width specification */
6044 }
6046 /* cp should now be pointing at type character */
6048 }
6050 /*
6051 * Format a %s, %I, or %L conversion
6052 */
6053 static void
6058 {
6061 /* Handle NULL arguments before trying to stringify the value. */
6063 {
6073 }
6075 /* Stringify. */
6078 /* Escape. */
6080 {
6081 /* quote_identifier may or may not allocate a new string. */
6083 }
6085 {
6089 /* quote_literal_cstr() always allocates a new string */
6091 }
6092 else
6095 /* Cleanup. */
6097 }
6099 /*
6100 * Append str to buf, padding as directed by flags/width
6101 */
6102 static void
6105 {
6109 /* fast path for typical easy case */
6111 {
6114 }
6117 {
6118 /* Negative width: implicit '-' flag, then take absolute value */
6120 /* -INT_MIN is undefined */
6126 }
6132 {
6133 /* left justify */
6137 }
6138 else
6139 {
6140 /* right justify */
6144 }
6145 }
6147 /*
6148 * text_format_nv - nonvariadic wrapper for text_format function.
6149 *
6150 * note: this wrapper is necessary to pass the sanity check in opr_sanity,
6151 * which checks that all built-in functions that share the implementing C
6152 * function take the same number of arguments.
6153 */
6154 Datum
6156 {
6158 }
6160 /*
6161 * Helper function for Levenshtein distance functions. Faster than memcmp(),
6162 * for this use case.
6163 */
6166 {
6168 {
6169 len--;
6172 }
6174 }
6176 /* Expand each Levenshtein distance variant */
6178 #define LEVENSHTEIN_LESS_EQUAL
6182 /*
6183 * The following *ClosestMatch() functions can be used to determine whether a
6184 * user-provided string resembles any known valid values, which is useful for
6185 * providing hints in log messages, among other things. Use these functions
6186 * like so:
6187 *
6188 * initClosestMatch(&state, source_string, max_distance);
6189 *
6190 * for (int i = 0; i < num_valid_strings; i++)
6191 * updateClosestMatch(&state, valid_strings[i]);
6192 *
6193 * closestMatch = getClosestMatch(&state);
6194 */
6196 /*
6197 * Initialize the given state with the source string and maximum Levenshtein
6198 * distance to consider.
6199 */
6200 void
6202 {
6210 }
6212 /*
6213 * If the candidate string is a closer match than the current one saved (or
6214 * there is no match saved), save it as the closest match.
6215 *
6216 * If the source or candidate string is NULL, empty, or too long, this function
6217 * takes no action. Likewise, if the Levenshtein distance exceeds the maximum
6218 * allowed or more than half the characters are different, no action is taken.
6219 */
6220 void
6222 {
6231 /*
6232 * To avoid ERROR-ing, we check the lengths here instead of setting
6233 * 'trusted' to false in the call to varstr_levenshtein_less_equal().
6234 */
6245 {
6248 }
6249 }
6251 /*
6252 * Return the closest match. If no suitable candidates were provided via
6253 * updateClosestMatch(), return NULL.
6254 */
6257 {
6261 }
6264 /*
6265 * Unicode support
6266 */
6268 static UnicodeNormalizationForm
6270 {
6273 /*
6274 * Might as well check this while we're here.
6275 */
6289 else
6295 }
6297 /*
6298 * Returns version of Unicode used by Postgres in "major.minor" format (the
6299 * same format as the Unicode version reported by ICU). The third component
6300 * ("update version") never involves additions to the character repertoire and
6301 * is unimportant for most purposes.
6302 *
6303 * See: https://unicode.org/versions/
6304 */
6305 Datum
6307 {
6309 }
6311 /*
6312 * Returns version of Unicode used by ICU, if enabled; otherwise NULL.
6313 */
6314 Datum
6316 {
6317 #ifdef USE_ICU
6319 #else
6321 #endif
6322 }
6324 /*
6325 * Check whether the string contains only assigned Unicode code
6326 * points. Requires that the database encoding is UTF-8.
6327 */
6328 Datum
6330 {
6339 /* convert to pg_wchar */
6343 {
6351 }
6354 }
6356 Datum
6358 {
6361 UnicodeNormalizationForm form;
6371 /* convert to pg_wchar */
6376 {
6379 }
6383 /* action */
6386 /* convert back to UTF-8 string */
6389 {
6394 }
6401 {
6404 }
6408 }
6410 /*
6411 * Check whether the string is in the specified Unicode normalization form.
6412 *
6413 * This is done by converting the string to the specified normal form and then
6414 * comparing that to the original string. To speed that up, we also apply the
6415 * "quick check" algorithm specified in UAX #15, which can give a yes or no
6416 * answer for many strings by just scanning the string once.
6417 *
6418 * This function should generally be optimized for the case where the string
6419 * is in fact normalized. In that case, we'll end up looking at the entire
6420 * string, so it's probably not worth doing any incremental conversion etc.
6421 */
6422 Datum
6424 {
6427 UnicodeNormalizationForm form;
6433 UnicodeNormalizationQC quickcheck;
6439 /* convert to pg_wchar */
6444 {
6447 }
6451 /* quick check (see UAX #15) */
6458 /* normalize and compare with original */
6463 output_size++;
6469 }
6471 /*
6472 * Check if first n chars are hexadecimal digits
6473 */
6474 static bool
6476 {
6482 }
6484 static unsigned int
6486 {
6495 }
6497 /*
6498 * Translate string with hexadecimal digits to number
6499 */
6500 static unsigned int
6502 {
6509 }
6511 /*
6512 * Replaces Unicode escape sequences by Unicode characters
6513 */
6514 Datum
6516 {
6520 StringInfoData str;
6531 {
6533 {
6536 {
6542 }
6545 {
6546 pg_wchar unicode;
6557 {
6559 {
6562 }
6563 else
6565 }
6571 else
6572 {
6575 }
6579 }
6581 {
6582 pg_wchar unicode;
6592 {
6594 {
6597 }
6598 else
6600 }
6606 else
6607 {
6610 }
6614 }
6616 {
6617 pg_wchar unicode;
6627 {
6629 {
6632 }
6633 else
6635 }
6641 else
6642 {
6645 }
6649 }
6650 else
6655 }
6656 else
6657 {
6662 len--;
6663 }
6664 }
6666 /* unfinished surrogate pair? */
6675 invalid_pair:
6680 }