| blob | b3eb39761d378cfa55b1b6ddf6f53d4c5b84fdb8 |
1 /*-------------------------------------------------------------------------
2 *
3 * varlena.c
4 * Functions for the variable-length built-in types.
5 *
6 * Portions Copyright (c) 1996-2022, 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>
43 /* GUC variable */
49 /*
50 * State for text_position_* functions.
51 */
53 {
62 /* Skip table for Boyer-Moore-Horspool search algorithm: */
68 /*
69 * Sometimes we need to convert the byte position of a match to a
70 * character position. These store the last position that was converted,
71 * so that on the next call, we can continue from that point, rather than
72 * count characters from the very beginning.
73 */
79 {
81 * buf */
94 pg_locale_t locale;
97 /*
98 * Output data for split_text(): we output either to an array or a table.
99 * tupstore and tupdesc must be set up in advance to output to a table.
100 */
102 {
105 TupleDesc tupdesc;
108 /*
109 * This should be large enough that most strings will fit, but small enough
110 * that we feel comfortable putting it on the stack
111 */
112 #define TEXTBUFLEN 1024
114 #define DatumGetUnknownP(X) ((unknown *) PG_DETOAST_DATUM(X))
115 #define DatumGetUnknownPCopy(X) ((unknown *) PG_DETOAST_DATUM_COPY(X))
116 #define PG_GETARG_UNKNOWN_P(n) DatumGetUnknownP(PG_GETARG_DATUM(n))
117 #define PG_GETARG_UNKNOWN_P_COPY(n) DatumGetUnknownPCopy(PG_GETARG_DATUM(n))
118 #define PG_RETURN_UNKNOWN_P(x) PG_RETURN_POINTER(x)
120 #define DatumGetVarStringP(X) ((VarString *) PG_DETOAST_DATUM(X))
121 #define DatumGetVarStringPP(X) ((VarString *) PG_DETOAST_DATUM_PACKED(X))
135 int32 start,
136 int32 length,
159 Oid collation);
177 /*****************************************************************************
178 * CONVERSION ROUTINES EXPORTED FOR USE BY C CODE *
179 *****************************************************************************/
181 /*
182 * cstring_to_text
183 *
184 * Create a text value from a null-terminated C string.
185 *
186 * The new text value is freshly palloc'd with a full-size VARHDR.
187 */
188 text *
190 {
192 }
194 /*
195 * cstring_to_text_with_len
196 *
197 * Same as cstring_to_text except the caller specifies the string length;
198 * the string need not be null_terminated.
199 */
200 text *
202 {
209 }
211 /*
212 * text_to_cstring
213 *
214 * Create a palloc'd, null-terminated C string from a text value.
215 *
216 * We support being passed a compressed or toasted text value.
217 * This is a bit bogus since such values shouldn't really be referred to as
218 * "text *", but it seems useful for robustness. If we didn't handle that
219 * case here, we'd need another routine that did, anyway.
220 */
223 {
224 /* must cast away the const, unfortunately */
237 }
239 /*
240 * text_to_cstring_buffer
241 *
242 * Copy a text value into a caller-supplied buffer of size dst_len.
243 *
244 * The text string is truncated if necessary to fit. The result is
245 * guaranteed null-terminated (unless dst_len == 0).
246 *
247 * We support being passed a compressed or toasted text value.
248 * This is a bit bogus since such values shouldn't really be referred to as
249 * "text *", but it seems useful for robustness. If we didn't handle that
250 * case here, we'd need another routine that did, anyway.
251 */
252 void
254 {
255 /* must cast away the const, unfortunately */
260 {
261 dst_len--;
268 }
272 }
275 /*****************************************************************************
276 * USER I/O ROUTINES *
277 *****************************************************************************/
283 /*
284 * byteain - converts from printable representation of byte array
285 *
286 * Non-printable characters must be passed as '\nnn' (octal) and are
287 * converted to internal form. '\' must be passed as '\\'.
288 * ereport(ERROR, ...) if bad form.
289 *
290 * BUGS:
291 * The input is scanned twice.
292 * The error checking of input is minimal.
293 */
294 Datum
296 {
303 /* Recognize hex input */
305 {
314 }
316 /* Else, it's the traditional escaped style */
318 {
320 tp++;
329 else
330 {
331 /*
332 * one backslash, not followed by another or ### valid octal
333 */
337 }
338 }
348 {
355 {
363 }
366 {
369 }
370 else
371 {
372 /*
373 * We should never get here. The first pass should not allow it.
374 */
378 }
379 }
382 }
384 /*
385 * byteaout - converts to printable representation of byte array
386 *
387 * In the traditional escaped format, non-printable characters are
388 * printed as '\nnn' (octal) and '\' as '\\'.
389 */
390 Datum
392 {
398 {
399 /* Print hex format */
404 }
406 {
407 /* Print traditional escaped format */
409 uint64 len;
415 {
420 else
421 len++;
422 }
424 /*
425 * In principle len can't overflow uint32 if the input fit in 1GB, but
426 * for safety let's check rather than relying on palloc's internal
427 * check.
428 */
437 {
439 {
442 }
444 {
455 }
456 else
458 }
459 }
460 else
461 {
463 bytea_output);
465 }
468 }
470 /*
471 * bytearecv - converts external binary format to bytea
472 */
473 Datum
475 {
485 }
487 /*
488 * byteasend - converts bytea to binary format
489 *
490 * This is a special case: just copy the input...
491 */
492 Datum
494 {
498 }
500 Datum
502 {
503 StringInfo state;
507 /* Append the value unless null. */
509 {
512 /* On the first time through, we ignore the delimiter. */
516 {
520 }
523 }
525 /*
526 * The transition type for string_agg() is declared to be "internal",
527 * which is a pass-by-value type the same size as a pointer.
528 */
530 }
532 Datum
534 {
535 StringInfo state;
537 /* cannot be called directly because of internal-type argument */
543 {
550 }
551 else
553 }
555 /*
556 * textin - converts "..." to internal representation
557 */
558 Datum
560 {
564 }
566 /*
567 * textout - converts internal representation to "..."
568 */
569 Datum
571 {
575 }
577 /*
578 * textrecv - converts external binary format to text
579 */
580 Datum
582 {
593 }
595 /*
596 * textsend - converts text to binary format
597 */
598 Datum
600 {
602 StringInfoData buf;
607 }
610 /*
611 * unknownin - converts "..." to internal representation
612 */
613 Datum
615 {
618 /* representation is same as cstring */
620 }
622 /*
623 * unknownout - converts internal representation to "..."
624 */
625 Datum
627 {
628 /* representation is same as cstring */
632 }
634 /*
635 * unknownrecv - converts external binary format to unknown
636 */
637 Datum
639 {
645 /* representation is same as cstring */
647 }
649 /*
650 * unknownsend - converts unknown to binary format
651 */
652 Datum
654 {
655 /* representation is same as cstring */
657 StringInfoData buf;
662 }
665 /* ========== PUBLIC ROUTINES ========== */
667 /*
668 * textlen -
669 * returns the logical length of a text*
670 * (which is less than the VARSIZE of the text*)
671 */
672 Datum
674 {
677 /* try to avoid decompressing argument */
679 }
681 /*
682 * text_length -
683 * Does the real work for textlen()
684 *
685 * This is broken out so it can be called directly by other string processing
686 * functions. Note that the argument is passed as a Datum, to indicate that
687 * it may still be in compressed form. We can avoid decompressing it at all
688 * in some cases.
689 */
690 static int32
692 {
693 /* fastpath when max encoding length is one */
696 else
697 {
702 }
703 }
705 /*
706 * textoctetlen -
707 * returns the physical length of a text*
708 * (which is less than the VARSIZE of the text*)
709 */
710 Datum
712 {
715 /* We need not detoast the input at all */
717 }
719 /*
720 * textcat -
721 * takes two text* and returns a text* that is the concatenation of
722 * the two.
723 *
724 * Rewritten by Sapa, sapa@hq.icb.chel.su. 8-Jul-96.
725 * Updated by Thomas, Thomas.Lockhart@jpl.nasa.gov 1997-07-10.
726 * Allocate space for output in all cases.
727 * XXX - thomas 1997-07-10
728 */
729 Datum
731 {
736 }
738 /*
739 * text_catenate
740 * Guts of textcat(), broken out so it can be used by other functions
741 *
742 * Arguments can be in short-header form, but not compressed or out-of-line
743 */
746 {
749 len2,
750 len;
756 /* paranoia ... probably should throw error instead? */
765 /* Set size of result string... */
768 /* Fill data field of result string... */
776 }
778 /*
779 * charlen_to_bytelen()
780 * Compute the number of bytes occupied by n characters starting at *p
781 *
782 * It is caller's responsibility that there actually are n characters;
783 * the string need not be null-terminated.
784 */
785 static int
787 {
789 {
790 /* Optimization for single-byte encodings */
792 }
793 else
794 {
801 }
802 }
804 /*
805 * text_substr()
806 * Return a substring starting at the specified position.
807 * - thomas 1997-12-31
808 *
809 * Input:
810 * - string
811 * - starting position (is one-based)
812 * - string length
813 *
814 * If the starting position is zero or less, then return from the start of the string
815 * adjusting the length to be consistent with the "negative start" per SQL.
816 * If the length is less than zero, return the remaining string.
817 *
818 * Added multibyte support.
819 * - Tatsuo Ishii 1998-4-21
820 * Changed behavior if starting position is less than one to conform to SQL behavior.
821 * Formerly returned the entire string; now returns a portion.
822 * - Thomas Lockhart 1998-12-10
823 * Now uses faster TOAST-slicing interface
824 * - John Gray 2002-02-22
825 * Remove "#ifdef MULTIBYTE" and test for encoding_max_length instead. Change
826 * behaviors conflicting with SQL to meet SQL (if E = S + L < S throw
827 * error; if E < 1, return '', not entire string). Fixed MB related bug when
828 * S > LC and < LC + 4 sometimes garbage characters are returned.
829 * - Joe Conway 2002-08-10
830 */
831 Datum
833 {
838 }
840 /*
841 * text_substr_no_len -
842 * Wrapper to avoid opr_sanity failure due to
843 * one function accepting a different number of args.
844 */
845 Datum
847 {
851 }
853 /*
854 * text_substring -
855 * Does the real work for text_substr() and text_substr_no_len()
856 *
857 * This is broken out so it can be called directly by other string processing
858 * functions. Note that the argument is passed as a Datum, to indicate that
859 * it may still be in compressed/toasted form. We can avoid detoasting all
860 * of it in some cases.
861 *
862 * The result is always a freshly palloc'd datum.
863 */
866 {
873 /*
874 * SQL99 says S can be zero or negative, but we still must fetch from the
875 * start of the string.
876 */
879 /* life is easy if the encoding max length is 1 */
881 {
883 * string */
886 {
887 /* SQL99 says to throw an error for E < S, i.e., negative length */
892 }
894 {
895 /*
896 * L could be large enough for S + L to overflow, in which case
897 * the substring must run to end of string.
898 */
900 }
901 else
902 {
903 /*
904 * A zero or negative value for the end position can happen if the
905 * start was negative or one. SQL99 says to return a zero-length
906 * string.
907 */
912 }
914 /*
915 * If the start position is past the end of the string, SQL99 says to
916 * return a zero-length string -- DatumGetTextPSlice() will do that
917 * for us. We need only convert S1 to zero-based starting position.
918 */
920 }
922 {
923 /*
924 * When encoding max length is > 1, we can't get LC without
925 * detoasting, so we'll grab a conservatively large slice now and go
926 * back later to do the right thing
927 */
928 int32 slice_start;
929 int32 slice_size;
930 int32 slice_strlen;
932 int32 E1;
933 int32 i;
938 /*
939 * We need to start at position zero because there is no way to know
940 * in advance which byte offset corresponds to the supplied start
941 * position.
942 */
946 * string */
949 {
950 /* SQL99 says to throw an error for E < S, i.e., negative length */
955 }
957 {
958 /*
959 * L could be large enough for S + L to overflow, in which case
960 * the substring must run to end of string.
961 */
963 }
964 else
965 {
966 /*
967 * A zero or negative value for the end position can happen if the
968 * start was negative or one. SQL99 says to return a zero-length
969 * string.
970 */
974 /*
975 * if E is past the end of the string, the tuple toaster will
976 * truncate the length for us
977 */
980 /*
981 * Total slice size in bytes can't be any longer than the start
982 * position plus substring length times the encoding max length.
983 * If that overflows, we can just use -1.
984 */
987 }
989 /*
990 * If we're working with an untoasted source, no need to do an extra
991 * copying step.
992 */
996 else
999 /* see if we got back an empty string */
1001 {
1005 }
1007 /* Now we can get the actual length of the slice in MB characters */
1011 /*
1012 * Check that the start position wasn't > slice_strlen. If so, SQL99
1013 * says to return a zero-length string.
1014 */
1016 {
1020 }
1022 /*
1023 * Adjust L1 and E1 now that we know the slice string length. Again
1024 * remember that S1 is one based, and slice_start is zero based.
1025 */
1028 else
1031 /*
1032 * Find the start position in the slice; remember S1 is not zero based
1033 */
1038 /* hang onto a pointer to our start position */
1041 /*
1042 * Count the actual bytes used by the substring of the requested
1043 * length.
1044 */
1056 }
1057 else
1060 /* not reached: suppress compiler warning */
1062 }
1064 /*
1065 * textoverlay
1066 * Replace specified substring of first string with second
1067 *
1068 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
1069 * This code is a direct implementation of what the standard says.
1070 */
1071 Datum
1073 {
1080 }
1082 Datum
1084 {
1092 }
1096 {
1102 /*
1103 * Check for possible integer-overflow cases. For negative sp, throw a
1104 * "substring length" error because that's what should be expected
1105 * according to the spec's definition of OVERLAY().
1106 */
1122 }
1124 /*
1125 * textpos -
1126 * Return the position of the specified substring.
1127 * Implements the SQL POSITION() function.
1128 * Ref: A Guide To The SQL Standard, Date & Darwen, 1997
1129 * - thomas 1997-07-27
1130 */
1131 Datum
1133 {
1138 }
1140 /*
1141 * text_position -
1142 * Does the real work for textpos()
1143 *
1144 * Inputs:
1145 * t1 - string to be searched
1146 * t2 - pattern to match within t1
1147 * Result:
1148 * Character index of the first matched char, starting from 1,
1149 * or 0 if no match.
1150 *
1151 * This is broken out so it can be called directly by other string processing
1152 * functions.
1153 */
1154 static int
1156 {
1157 TextPositionState state;
1160 /* Empty needle always matches at position 1 */
1164 /* Otherwise, can't match if haystack is shorter than needle */
1171 else
1175 }
1178 /*
1179 * text_position_setup, text_position_next, text_position_cleanup -
1180 * Component steps of text_position()
1181 *
1182 * These are broken out so that a string can be efficiently searched for
1183 * multiple occurrences of the same pattern. text_position_next may be
1184 * called multiple times, and it advances to the next match on each call.
1185 * text_position_get_match_ptr() and text_position_get_match_pos() return
1186 * a pointer or 1-based character position of the last match, respectively.
1187 *
1188 * The "state" variable is normally just a local variable in the caller.
1189 *
1190 * NOTE: text_position_next skips over the matched portion. For example,
1191 * searching for "xx" in "xxx" returns only one match, not two.
1192 */
1194 static void
1196 {
1214 /*
1215 * Even with a multi-byte encoding, we perform the search using the raw
1216 * byte sequence, ignoring multibyte issues. For UTF-8, that works fine,
1217 * because in UTF-8 the byte sequence of one character cannot contain
1218 * another character. For other multi-byte encodings, we do the search
1219 * initially as a simple byte search, ignoring multibyte issues, but
1220 * verify afterwards that the match we found is at a character boundary,
1221 * and continue the search if it was a false match.
1222 */
1224 {
1227 }
1229 {
1232 }
1233 else
1234 {
1237 }
1247 /*
1248 * Prepare the skip table for Boyer-Moore-Horspool searching. In these
1249 * notes we use the terminology that the "haystack" is the string to be
1250 * searched (t1) and the "needle" is the pattern being sought (t2).
1251 *
1252 * If the needle is empty or bigger than the haystack then there is no
1253 * point in wasting cycles initializing the table. We also choose not to
1254 * use B-M-H for needles of length 1, since the skip table can't possibly
1255 * save anything in that case.
1256 */
1258 {
1265 /*
1266 * First we must determine how much of the skip table to use. The
1267 * declaration of TextPositionState allows up to 256 elements, but for
1268 * short search problems we don't really want to have to initialize so
1269 * many elements --- it would take too long in comparison to the
1270 * actual search time. So we choose a useful skip table size based on
1271 * the haystack length minus the needle length. The closer the needle
1272 * length is to the haystack length the less useful skipping becomes.
1273 *
1274 * Note: since we use bit-masking to select table elements, the skip
1275 * table size MUST be a power of 2, and so the mask must be 2^N-1.
1276 */
1289 else
1293 /*
1294 * Initialize the skip table. We set all elements to the needle
1295 * length, since this is the correct skip distance for any character
1296 * not found in the needle.
1297 */
1301 /*
1302 * Now examine the needle. For each character except the last one,
1303 * set the corresponding table element to the appropriate skip
1304 * distance. Note that when two characters share the same skip table
1305 * entry, the one later in the needle must determine the skip
1306 * distance.
1307 */
1312 }
1313 }
1315 /*
1316 * Advance to the next match, starting from the end of the previous match
1317 * (or the beginning of the string, on first call). Returns true if a match
1318 * is found.
1319 *
1320 * Note that this refuses to match an empty-string needle. Most callers
1321 * will have handled that case specially and we'll never see it here.
1322 */
1323 static bool
1325 {
1333 /* Start from the point right after the previous match. */
1336 else
1339 retry:
1345 /*
1346 * Found a match for the byte sequence. If this is a multibyte encoding,
1347 * where one character's byte sequence can appear inside a longer
1348 * multi-byte character, we need to verify that the match was at a
1349 * character boundary, not in the middle of a multi-byte character.
1350 */
1352 {
1353 /* Walk one character at a time, until we reach the match. */
1355 /* the search should never move backwards. */
1359 {
1360 /* step to next character. */
1364 /*
1365 * If we stepped over the match's start position, then it was a
1366 * false positive, where the byte sequence appeared in the middle
1367 * of a multi-byte character. Skip it, and continue the search at
1368 * the next character boundary.
1369 */
1371 {
1374 }
1375 }
1376 }
1380 }
1382 /*
1383 * Subroutine of text_position_next(). This searches for the raw byte
1384 * sequence, ignoring any multi-byte encoding issues. Returns the first
1385 * match starting at 'start_ptr', or NULL if no match is found.
1386 */
1389 {
1401 {
1402 /* No point in using B-M-H for a one-character needle */
1407 {
1410 hptr++;
1411 }
1412 }
1413 else
1414 {
1417 /* Start at startpos plus the length of the needle */
1420 {
1421 /* Match the needle scanning *backward* */
1428 {
1429 /* Matched it all? If so, return 1-based position */
1433 }
1435 /*
1436 * No match, so use the haystack char at hptr to decide how far to
1437 * advance. If the needle had any occurrence of that character
1438 * (or more precisely, one sharing the same skiptable entry)
1439 * before its last character, then we advance far enough to align
1440 * the last such needle character with that haystack position.
1441 * Otherwise we can advance by the whole needle length.
1442 */
1444 }
1445 }
1448 }
1450 /*
1451 * Return a pointer to the current match.
1452 *
1453 * The returned pointer points into the original haystack string.
1454 */
1457 {
1459 }
1461 /*
1462 * Return the offset of the current match.
1463 *
1464 * The offset is in characters, 1-based.
1465 */
1466 static int
1468 {
1471 else
1472 {
1473 /* Convert the byte position to char position. */
1475 {
1478 }
1481 }
1482 }
1484 /*
1485 * Reset search state to the initial state installed by text_position_setup.
1486 *
1487 * The next call to text_position_next will search from the beginning
1488 * of the string.
1489 */
1490 static void
1492 {
1496 }
1498 static void
1500 {
1501 /* no cleanup needed */
1502 }
1505 static void
1507 {
1509 {
1510 /*
1511 * This typically means that the parser could not resolve a conflict
1512 * of implicit collations, so report it that way.
1513 */
1518 }
1519 }
1521 /* varstr_cmp()
1522 * Comparison function for text strings with given lengths.
1523 * Includes locale support, but must copy strings to temporary memory
1524 * to allow null-termination for inputs to strcoll().
1525 * Returns an integer less than, equal to, or greater than zero, indicating
1526 * whether arg1 is less than, equal to, or greater than arg2.
1527 *
1528 * Note: many functions that depend on this are marked leakproof; therefore,
1529 * avoid reporting the actual contents of the input when throwing errors.
1530 * All errors herein should be things that can't happen except on corrupt
1531 * data, anyway; otherwise we will have trouble with indexing strings that
1532 * would cause them.
1533 */
1534 int
1536 {
1541 /*
1542 * Unfortunately, there is no strncoll(), so in the non-C locale case we
1543 * have to do some memory copying. This turns out to be significantly
1544 * slower, so we optimize the case where LC_COLLATE is C. We also try to
1545 * optimize relatively-short strings by avoiding palloc/pfree overhead.
1546 */
1548 {
1552 }
1553 else
1554 {
1564 /*
1565 * memcmp() can't tell us which of two unequal strings sorts first,
1566 * but it's a cheap way to tell if they're equal. Testing shows that
1567 * memcmp() followed by strcoll() is only trivially slower than
1568 * strcoll() by itself, so we don't lose much if this doesn't work out
1569 * very often, and if it does - for example, because there are many
1570 * equal strings in the input - then we win big by avoiding expensive
1571 * collation-aware comparisons.
1572 */
1576 #ifdef WIN32
1577 /* Win32 does not have UTF-8, so we need to map to UTF-16 */
1580 {
1586 {
1589 }
1590 else
1591 {
1594 }
1596 {
1599 }
1600 else
1601 {
1604 }
1606 /* stupid Microsloth API does not work for zero-length input */
1609 else
1610 {
1617 }
1622 else
1623 {
1630 }
1634 #ifdef HAVE_LOCALE_T
1637 else
1638 #endif
1641 * headers */
1645 /* Break tie if necessary. */
1648 {
1652 }
1660 }
1665 else
1669 else
1678 {
1680 {
1681 #ifdef USE_ICU
1682 #ifdef HAVE_UCOL_STRCOLLUTF8
1684 {
1685 UErrorCode status;
1695 }
1696 else
1697 #endif
1698 {
1700 ulen2;
1713 }
1715 /* shouldn't happen */
1718 }
1719 else
1720 {
1721 #ifdef HAVE_LOCALE_T
1723 #else
1724 /* shouldn't happen */
1726 #endif
1727 }
1728 }
1729 else
1732 /* Break tie if necessary. */
1741 }
1744 }
1746 /* text_cmp()
1747 * Internal comparison function for text strings.
1748 * Returns -1, 0 or 1
1749 */
1750 static int
1752 {
1756 len2;
1765 }
1767 /*
1768 * Comparison functions for text strings.
1769 *
1770 * Note: btree indexes need these routines not to leak memory; therefore,
1771 * be careful to free working copies of toasted datums. Most places don't
1772 * need to be so careful.
1773 */
1775 Datum
1777 {
1786 {
1789 Size len1,
1790 len2;
1792 /*
1793 * Since we only care about equality or not-equality, we can avoid all
1794 * the expense of strcoll() here, and just do bitwise comparison. In
1795 * fact, we don't even have to do a bitwise comparison if we can show
1796 * the lengths of the strings are unequal; which might save us from
1797 * having to detoast one or both values.
1798 */
1803 else
1804 {
1813 }
1814 }
1815 else
1816 {
1824 }
1827 }
1829 Datum
1831 {
1840 {
1843 Size len1,
1844 len2;
1846 /* See comment in texteq() */
1851 else
1852 {
1861 }
1862 }
1863 else
1864 {
1872 }
1875 }
1877 Datum
1879 {
1890 }
1892 Datum
1894 {
1905 }
1907 Datum
1909 {
1920 }
1922 Datum
1924 {
1935 }
1937 Datum
1939 {
1945 Size len1,
1946 len2;
1962 else
1963 {
1972 }
1975 }
1977 Datum
1979 {
1982 int32 result;
1990 }
1992 Datum
1994 {
1997 MemoryContext oldcontext;
2001 /* Use generic string SortSupport */
2007 }
2009 /*
2010 * Generic sortsupport interface for character type's operator classes.
2011 * Includes locale support, and support for BpChar semantics (i.e. removing
2012 * trailing spaces before comparison).
2013 *
2014 * Relies on the assumption that text, VarChar, BpChar, and bytea all have the
2015 * same representation. Callers that always use the C collation (e.g.
2016 * non-collatable type callers like bytea) may have NUL bytes in their strings;
2017 * this will not work with any other collation, though.
2018 */
2019 void
2021 {
2029 /*
2030 * If possible, set ssup->comparator to a function which can be used to
2031 * directly compare two datums. If we can do this, we'll avoid the
2032 * overhead of a trip through the fmgr layer for every comparison, which
2033 * can be substantial.
2034 *
2035 * Most typically, we'll set the comparator to varlenafastcmp_locale,
2036 * which uses strcoll() to perform comparisons. We use that for the
2037 * BpChar case too, but type NAME uses namefastcmp_locale. However, if
2038 * LC_COLLATE = C, we can make things quite a bit faster with
2039 * varstrfastcmp_c, bpcharfastcmp_c, or namefastcmp_c, all of which use
2040 * memcmp() rather than strcoll().
2041 */
2043 {
2047 {
2049 /* Not supporting abbreviation with type NAME, for now */
2051 }
2052 else
2056 }
2057 else
2058 {
2059 /*
2060 * We need a collation-sensitive comparison. To make things faster,
2061 * we'll figure out the collation based on the locale id and cache the
2062 * result.
2063 */
2067 /*
2068 * There is a further exception on Windows. When the database
2069 * encoding is UTF-8 and we are not using the C collation, complex
2070 * hacks are required. We don't currently have a comparator that
2071 * handles that case, so we fall back on the slow method of having the
2072 * sort code invoke bttextcmp() (in the case of text) via the fmgr
2073 * trampoline. ICU locales work just the same on Windows, however.
2074 */
2075 #ifdef WIN32
2079 #endif
2081 /*
2082 * We use varlenafastcmp_locale except for type NAME.
2083 */
2085 {
2087 /* Not supporting abbreviation with type NAME, for now */
2089 }
2090 else
2092 }
2094 /*
2095 * Unfortunately, it seems that abbreviation for non-C collations is
2096 * broken on many common platforms; testing of multiple versions of glibc
2097 * reveals that, for many locales, strcoll() and strxfrm() do not return
2098 * consistent results, which is fatal to this optimization. While no
2099 * other libc other than Cygwin has so far been shown to have a problem,
2100 * we take the conservative course of action for right now and disable
2101 * this categorically. (Users who are certain this isn't a problem on
2102 * their system can define TRUST_STRXFRM.)
2103 *
2104 * Even apart from the risk of broken locales, it's possible that there
2105 * are platforms where the use of abbreviated keys should be disabled at
2106 * compile time. Having only 4 byte datums could make worst-case
2107 * performance drastically more likely, for example. Moreover, macOS's
2108 * strxfrm() implementation is known to not effectively concentrate a
2109 * significant amount of entropy from the original string in earlier
2110 * transformed blobs. It's possible that other supported platforms are
2111 * similarly encumbered. So, if we ever get past disabling this
2112 * categorically, we may still want or need to disable it for particular
2113 * platforms.
2114 */
2115 #ifndef TRUST_STRXFRM
2118 #endif
2120 /*
2121 * If we're using abbreviated keys, or if we're using a locale-aware
2122 * comparison, we need to initialize a VarStringSortSupport object. Both
2123 * cases will make use of the temporary buffers we initialize here for
2124 * scratch space (and to detect requirement for BpChar semantics from
2125 * caller), and the abbreviation case requires additional state.
2126 */
2128 {
2134 /* Start with invalid values */
2137 /* Initialize */
2141 /*
2142 * To avoid somehow confusing a strxfrm() blob and an original string,
2143 * constantly keep track of the variety of data that buf1 and buf2
2144 * currently contain.
2145 *
2146 * Comparisons may be interleaved with conversion calls. Frequently,
2147 * conversions and comparisons are batched into two distinct phases,
2148 * but the correctness of caching cannot hinge upon this. For
2149 * comparison caching, buffer state is only trusted if cache_blob is
2150 * found set to false, whereas strxfrm() caching only trusts the state
2151 * when cache_blob is found set to true.
2152 *
2153 * Arbitrarily initialize cache_blob to true.
2154 */
2160 /*
2161 * If possible, plan to use the abbreviated keys optimization. The
2162 * core code may switch back to authoritative comparator should
2163 * abbreviation be aborted.
2164 */
2166 {
2174 }
2175 }
2176 }
2178 /*
2179 * sortsupport comparison func (for C locale case)
2180 */
2181 static int
2183 {
2189 len2,
2190 result;
2202 /* We can't afford to leak memory here. */
2209 }
2211 /*
2212 * sortsupport comparison func (for BpChar C locale case)
2213 *
2214 * BpChar outsources its sortsupport to this module. Specialization for the
2215 * varstr_sortsupport BpChar case, modeled on
2216 * internal_bpchar_pattern_compare().
2217 */
2218 static int
2220 {
2226 len2,
2227 result;
2239 /* We can't afford to leak memory here. */
2246 }
2248 /*
2249 * sortsupport comparison func (for NAME C locale case)
2250 */
2251 static int
2253 {
2258 }
2260 /*
2261 * sortsupport comparison func (for locale case with all varlena types)
2262 */
2263 static int
2265 {
2271 len2,
2272 result;
2282 /* We can't afford to leak memory here. */
2289 }
2291 /*
2292 * sortsupport comparison func (for locale case with NAME type)
2293 */
2294 static int
2296 {
2302 ssup);
2303 }
2305 /*
2306 * sortsupport comparison func for locale cases
2307 */
2308 static int
2310 {
2315 /* Fast pre-check for equality, as discussed in varstr_cmp() */
2317 {
2318 /*
2319 * No change in buf1 or buf2 contents, so avoid changing last_len1 or
2320 * last_len2. Existing contents of buffers might still be used by
2321 * next call.
2322 *
2323 * It's fine to allow the comparison of BpChar padding bytes here,
2324 * even though that implies that the memcmp() will usually be
2325 * performed for BpChar callers (though multibyte characters could
2326 * still prevent that from occurring). The memcmp() is still very
2327 * cheap, and BpChar's funny semantics have us remove trailing spaces
2328 * (not limited to padding), so we need make no distinction between
2329 * padding space characters and "real" space characters.
2330 */
2332 }
2335 {
2336 /* Get true number of bytes, ignoring trailing spaces */
2339 }
2342 {
2346 }
2348 {
2352 }
2354 /*
2355 * We're likely to be asked to compare the same strings repeatedly, and
2356 * memcmp() is so much cheaper than strcoll() that it pays to try to cache
2357 * comparisons, even though in general there is no reason to think that
2358 * that will work out (every string datum may be unique). Caching does
2359 * not slow things down measurably when it doesn't work out, and can speed
2360 * things up by rather a lot when it does. In part, this is because the
2361 * memcmp() compares data from cachelines that are needed in L1 cache even
2362 * when the last comparison's result cannot be reused.
2363 */
2366 {
2371 }
2373 /*
2374 * If we're comparing the same two strings as last time, we can return the
2375 * same answer without calling strcoll() again. This is more likely than
2376 * it seems (at least with moderate to low cardinality sets), because
2377 * quicksort compares the same pivot against many values.
2378 */
2380 {
2384 }
2386 {
2387 /* Use result cached following last actual strcoll() call */
2389 }
2392 {
2394 {
2395 #ifdef USE_ICU
2396 #ifdef HAVE_UCOL_STRCOLLUTF8
2398 {
2399 UErrorCode status;
2409 }
2410 else
2411 #endif
2412 {
2414 ulen2;
2427 }
2429 /* shouldn't happen */
2432 }
2433 else
2434 {
2435 #ifdef HAVE_LOCALE_T
2437 #else
2438 /* shouldn't happen */
2440 #endif
2441 }
2442 }
2443 else
2446 /* Break tie if necessary. */
2451 /* Cache result, perhaps saving an expensive strcoll() call next time */
2455 }
2457 /*
2458 * Abbreviated key comparison func
2459 */
2460 static int
2462 {
2463 /*
2464 * When 0 is returned, the core system will call varstrfastcmp_c()
2465 * (bpcharfastcmp_c() in BpChar case) or varlenafastcmp_locale(). Even a
2466 * strcmp() on two non-truncated strxfrm() blobs cannot indicate *equality*
2467 * authoritatively, for the same reason that there is a strcoll()
2468 * tie-breaker call to strcmp() in varstr_cmp().
2469 */
2474 else
2476 }
2478 /*
2479 * Conversion routine for sortsupport. Converts original to abbreviated key
2480 * representation. Our encoding strategy is simple -- pack the first 8 bytes
2481 * of a strxfrm() blob into a Datum (on little-endian machines, the 8 bytes are
2482 * stored in reverse order), and treat it as an unsigned integer. When the "C"
2483 * locale is used, or in case of bytea, just memcpy() from original instead.
2484 */
2485 static Datum
2487 {
2492 /* working state */
2493 Datum res;
2496 uint32 hash;
2499 /* memset(), so any non-overwritten bytes are NUL */
2503 /* Get number of bytes, ignoring trailing spaces */
2507 /*
2508 * If we're using the C collation, use memcpy(), rather than strxfrm(), to
2509 * abbreviate keys. The full comparator for the C locale is always
2510 * memcmp(). It would be incorrect to allow bytea callers (callers that
2511 * always force the C collation -- bytea isn't a collatable type, but this
2512 * approach is convenient) to use strxfrm(). This is because bytea
2513 * strings may contain NUL bytes. Besides, this should be faster, too.
2514 *
2515 * More generally, it's okay that bytea callers can have NUL bytes in
2516 * strings because varstrcmp_abbrev() need not make a distinction between
2517 * terminating NUL bytes, and NUL bytes representing actual NULs in the
2518 * authoritative representation. Hopefully a comparison at or past one
2519 * abbreviated key's terminating NUL byte will resolve the comparison
2520 * without consulting the authoritative representation; specifically, some
2521 * later non-NUL byte in the longer string can resolve the comparison
2522 * against a subsequent terminating NUL in the shorter string. There will
2523 * usually be what is effectively a "length-wise" resolution there and
2524 * then.
2525 *
2526 * If that doesn't work out -- if all bytes in the longer string
2527 * positioned at or past the offset of the smaller string's (first)
2528 * terminating NUL are actually representative of NUL bytes in the
2529 * authoritative binary string (perhaps with some *terminating* NUL bytes
2530 * towards the end of the longer string iff it happens to still be small)
2531 * -- then an authoritative tie-breaker will happen, and do the right
2532 * thing: explicitly consider string length.
2533 */
2536 else
2537 {
2538 Size bsize;
2539 #ifdef USE_ICU
2542 #endif
2544 /*
2545 * We're not using the C collation, so fall back on strxfrm or ICU
2546 * analogs.
2547 */
2549 /* By convention, we use buffer 1 to store and NUL-terminate */
2551 {
2555 }
2557 /* Might be able to reuse strxfrm() blob from last call */
2560 {
2562 /* No change affecting cardinality, so no hashing required */
2564 }
2568 /*
2569 * Just like strcoll(), strxfrm() expects a NUL-terminated string. Not
2570 * necessary for ICU, but doesn't hurt.
2571 */
2575 #ifdef USE_ICU
2576 /* When using ICU and not UTF8, convert string to UChar. */
2580 #endif
2582 /*
2583 * Loop: Call strxfrm() or ucol_getSortKey(), possibly enlarge buffer,
2584 * and try again. Both of these functions have the result buffer
2585 * content undefined if the result did not fit, so we need to retry
2586 * until everything fits, even though we only need the first few bytes
2587 * in the end. When using ucol_nextSortKeyPart(), however, we only
2588 * ask for as many bytes as we actually need.
2589 */
2591 {
2592 #ifdef USE_ICU
2594 {
2595 /*
2596 * When using UTF8, use the iteration interface so we only
2597 * need to produce as many bytes as we actually need.
2598 */
2600 {
2601 UCharIterator iter;
2603 UErrorCode status;
2610 state,
2618 }
2619 else
2623 }
2624 else
2625 #endif
2626 #ifdef HAVE_LOCALE_T
2630 else
2631 #endif
2638 /*
2639 * Grow buffer and retry.
2640 */
2645 }
2647 /*
2648 * Every Datum byte is always compared. This is safe because the
2649 * strxfrm() blob is itself NUL terminated, leaving no danger of
2650 * misinterpreting any NUL bytes not intended to be interpreted as
2651 * logically representing termination.
2652 *
2653 * (Actually, even if there were NUL bytes in the blob it would be
2654 * okay. See remarks on bytea case above.)
2655 */
2658 #ifdef USE_ICU
2661 #endif
2662 }
2664 /*
2665 * Maintain approximate cardinality of both abbreviated keys and original,
2666 * authoritative keys using HyperLogLog. Used as cheap insurance against
2667 * the worst case, where we do many string transformations for no saving
2668 * in full strcoll()-based comparisons. These statistics are used by
2669 * varstr_abbrev_abort().
2670 *
2671 * First, Hash key proper, or a significant fraction of it. Mix in length
2672 * in order to compensate for cases where differences are past
2673 * PG_CACHE_LINE_SIZE bytes, so as to limit the overhead of hashing.
2674 */
2683 /* Hash abbreviated key */
2684 #if SIZEOF_DATUM == 8
2685 {
2686 uint32 lohalf,
2687 hihalf;
2692 }
2695 #endif
2699 /* Cache result, perhaps saving an expensive strxfrm() call next time */
2701 done:
2703 /*
2704 * Byteswap on little-endian machines.
2705 *
2706 * This is needed so that varstrcmp_abbrev() (an unsigned integer 3-way
2707 * comparator) works correctly on all platforms. If we didn't do this,
2708 * the comparator would have to call memcmp() with a pair of pointers to
2709 * the first byte of each abbreviated key, which is slower.
2710 */
2713 /* Don't leak memory here */
2718 }
2720 /*
2721 * Callback for estimating effectiveness of abbreviated key optimization, using
2722 * heuristic rules. Returns value indicating if the abbreviation optimization
2723 * should be aborted, based on its projected effectiveness.
2724 */
2725 static bool
2727 {
2730 key_distinct;
2734 /* Have a little patience */
2741 /*
2742 * Clamp cardinality estimates to at least one distinct value. While
2743 * NULLs are generally disregarded, if only NULL values were seen so far,
2744 * that might misrepresent costs if we failed to clamp.
2745 */
2752 /*
2753 * In the worst case all abbreviated keys are identical, while at the same
2754 * time there are differences within full key strings not captured in
2755 * abbreviations.
2756 */
2757 #ifdef TRACE_SORT
2759 {
2766 }
2767 #endif
2769 /*
2770 * If the number of distinct abbreviated keys approximately matches the
2771 * number of distinct authoritative original keys, that's reason enough to
2772 * proceed. We can win even with a very low cardinality set if most
2773 * tie-breakers only memcmp(). This is by far the most important
2774 * consideration.
2775 *
2776 * While comparisons that are resolved at the abbreviated key level are
2777 * considerably cheaper than tie-breakers resolved with memcmp(), both of
2778 * those two outcomes are so much cheaper than a full strcoll() once
2779 * sorting is underway that it doesn't seem worth it to weigh abbreviated
2780 * cardinality against the overall size of the set in order to more
2781 * accurately model costs. Assume that an abbreviated comparison, and an
2782 * abbreviated comparison with a cheap memcmp()-based authoritative
2783 * resolution are equivalent.
2784 */
2786 {
2787 /*
2788 * When we have exceeded 10,000 tuples, decay required cardinality
2789 * aggressively for next call.
2790 *
2791 * This is useful because the number of comparisons required on
2792 * average increases at a linearithmic rate, and at roughly 10,000
2793 * tuples that factor will start to dominate over the linear costs of
2794 * string transformation (this is a conservative estimate). The decay
2795 * rate is chosen to be a little less aggressive than halving -- which
2796 * (since we're called at points at which memtupcount has doubled)
2797 * would never see the cost model actually abort past the first call
2798 * following a decay. This decay rate is mostly a precaution against
2799 * a sudden, violent swing in how well abbreviated cardinality tracks
2800 * full key cardinality. The decay also serves to prevent a marginal
2801 * case from being aborted too late, when too much has already been
2802 * invested in string transformation.
2803 *
2804 * It's possible for sets of several million distinct strings with
2805 * mere tens of thousands of distinct abbreviated keys to still
2806 * benefit very significantly. This will generally occur provided
2807 * each abbreviated key is a proxy for a roughly uniform number of the
2808 * set's full keys. If it isn't so, we hope to catch that early and
2809 * abort. If it isn't caught early, by the time the problem is
2810 * apparent it's probably not worth aborting.
2811 */
2816 }
2818 /*
2819 * Abort abbreviation strategy.
2820 *
2821 * The worst case, where all abbreviated keys are identical while all
2822 * original strings differ will typically only see a regression of about
2823 * 10% in execution time for small to medium sized lists of strings.
2824 * Whereas on modern CPUs where cache stalls are the dominant cost, we can
2825 * often expect very large improvements, particularly with sets of strings
2826 * of moderately high to high abbreviated cardinality. There is little to
2827 * lose but much to gain, which our strategy reflects.
2828 */
2829 #ifdef TRACE_SORT
2834 #endif
2837 }
2839 /*
2840 * Generic equalimage support function for character type's operator classes.
2841 * Disables the use of deduplication with nondeterministic collations.
2842 */
2843 Datum
2845 {
2846 /* Oid opcintype = PG_GETARG_OID(0); */
2855 else
2857 }
2859 Datum
2861 {
2869 }
2871 Datum
2873 {
2881 }
2884 /*
2885 * Cross-type comparison functions for types text and name.
2886 */
2888 Datum
2890 {
2903 else
2911 }
2913 Datum
2915 {
2928 else
2936 }
2938 Datum
2940 {
2953 else
2961 }
2963 Datum
2965 {
2978 else
2986 }
2988 Datum
2990 {
2993 int32 result;
3002 }
3004 Datum
3006 {
3009 int32 result;
3018 }
3020 #define CmpCall(cmpfunc) \
3021 DatumGetInt32(DirectFunctionCall2Coll(cmpfunc, \
3022 PG_GET_COLLATION(), \
3023 PG_GETARG_DATUM(0), \
3024 PG_GETARG_DATUM(1)))
3026 Datum
3028 {
3030 }
3032 Datum
3034 {
3036 }
3038 Datum
3040 {
3042 }
3044 Datum
3046 {
3048 }
3050 Datum
3052 {
3054 }
3056 Datum
3058 {
3060 }
3062 Datum
3064 {
3066 }
3068 Datum
3070 {
3072 }
3074 #undef CmpCall
3077 /*
3078 * The following operators support character-by-character comparison
3079 * of text datums, to allow building indexes suitable for LIKE clauses.
3080 * Note that the regular texteq/textne comparison operators, and regular
3081 * support functions 1 and 2 with "C" collation are assumed to be
3082 * compatible with these!
3083 */
3085 static int
3087 {
3090 len2;
3102 else
3104 }
3107 Datum
3109 {
3120 }
3123 Datum
3125 {
3136 }
3139 Datum
3141 {
3152 }
3155 Datum
3157 {
3168 }
3171 Datum
3173 {
3184 }
3187 Datum
3189 {
3191 MemoryContext oldcontext;
3195 /* Use generic string SortSupport, forcing "C" collation */
3201 }
3204 /*-------------------------------------------------------------
3205 * byteaoctetlen
3206 *
3207 * get the number of bytes contained in an instance of type 'bytea'
3208 *-------------------------------------------------------------
3209 */
3210 Datum
3212 {
3215 /* We need not detoast the input at all */
3217 }
3219 /*
3220 * byteacat -
3221 * takes two bytea* and returns a bytea* that is the concatenation of
3222 * the two.
3223 *
3224 * Cloned from textcat and modified as required.
3225 */
3226 Datum
3228 {
3233 }
3235 /*
3236 * bytea_catenate
3237 * Guts of byteacat(), broken out so it can be used by other functions
3238 *
3239 * Arguments can be in short-header form, but not compressed or out-of-line
3240 */
3243 {
3246 len2,
3247 len;
3253 /* paranoia ... probably should throw error instead? */
3262 /* Set size of result string... */
3265 /* Fill data field of result string... */
3273 }
3275 #define PG_STR_GET_BYTEA(str_) \
3276 DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))
3278 /*
3279 * bytea_substr()
3280 * Return a substring starting at the specified position.
3281 * Cloned from text_substr and modified as required.
3282 *
3283 * Input:
3284 * - string
3285 * - starting position (is one-based)
3286 * - string length (optional)
3287 *
3288 * If the starting position is zero or less, then return from the start of the string
3289 * adjusting the length to be consistent with the "negative start" per SQL.
3290 * If the length is less than zero, an ERROR is thrown. If no third argument
3291 * (length) is provided, the length to the end of the string is assumed.
3292 */
3293 Datum
3295 {
3300 }
3302 /*
3303 * bytea_substr_no_len -
3304 * Wrapper to avoid opr_sanity failure due to
3305 * one function accepting a different number of args.
3306 */
3307 Datum
3309 {
3314 }
3321 {
3326 /*
3327 * The logic here should generally match text_substring().
3328 */
3332 {
3333 /*
3334 * Not passed a length - DatumGetByteaPSlice() grabs everything to the
3335 * end of the string if we pass it a negative value for length.
3336 */
3338 }
3340 {
3341 /* SQL99 says to throw an error for E < S, i.e., negative length */
3346 }
3348 {
3349 /*
3350 * L could be large enough for S + L to overflow, in which case the
3351 * substring must run to end of string.
3352 */
3354 }
3355 else
3356 {
3357 /*
3358 * A zero or negative value for the end position can happen if the
3359 * start was negative or one. SQL99 says to return a zero-length
3360 * string.
3361 */
3366 }
3368 /*
3369 * If the start position is past the end of the string, SQL99 says to
3370 * return a zero-length string -- DatumGetByteaPSlice() will do that for
3371 * us. We need only convert S1 to zero-based starting position.
3372 */
3374 }
3376 /*
3377 * byteaoverlay
3378 * Replace specified substring of first string with second
3379 *
3380 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
3381 * This code is a direct implementation of what the standard says.
3382 */
3383 Datum
3385 {
3392 }
3394 Datum
3396 {
3404 }
3408 {
3414 /*
3415 * Check for possible integer-overflow cases. For negative sp, throw a
3416 * "substring length" error because that's what should be expected
3417 * according to the spec's definition of OVERLAY().
3418 */
3434 }
3436 /*
3437 * bit_count
3438 */
3439 Datum
3441 {
3445 }
3447 /*
3448 * byteapos -
3449 * Return the position of the specified substring.
3450 * Implements the SQL POSITION() function.
3451 * Cloned from textpos and modified as required.
3452 */
3453 Datum
3455 {
3460 p;
3462 len2;
3478 {
3480 {
3483 };
3484 p1++;
3485 };
3488 }
3490 /*-------------------------------------------------------------
3491 * byteaGetByte
3492 *
3493 * this routine treats "bytea" as an array of bytes.
3494 * It returns the Nth byte (a number between 0 and 255).
3495 *-------------------------------------------------------------
3496 */
3497 Datum
3499 {
3516 }
3518 /*-------------------------------------------------------------
3519 * byteaGetBit
3520 *
3521 * This routine treats a "bytea" type like an array of bits.
3522 * It returns the value of the Nth bit (0 or 1).
3523 *
3524 *-------------------------------------------------------------
3525 */
3526 Datum
3528 {
3532 bitNo;
3544 /* n/8 is now known < len, so safe to cast to int */
3552 else
3554 }
3556 /*-------------------------------------------------------------
3557 * byteaSetByte
3558 *
3559 * Given an instance of type 'bytea' creates a new one with
3560 * the Nth byte set to the given value.
3561 *
3562 *-------------------------------------------------------------
3563 */
3564 Datum
3566 {
3580 /*
3581 * Now set the byte.
3582 */
3586 }
3588 /*-------------------------------------------------------------
3589 * byteaSetBit
3590 *
3591 * Given an instance of type 'bytea' creates a new one with
3592 * the Nth bit set to the given value.
3593 *
3594 *-------------------------------------------------------------
3595 */
3596 Datum
3598 {
3604 newByte;
3606 bitNo;
3616 /* n/8 is now known < len, so safe to cast to int */
3620 /*
3621 * sanity check!
3622 */
3628 /*
3629 * Update the byte.
3630 */
3635 else
3641 }
3644 /* text_name()
3645 * Converts a text type to a Name type.
3646 */
3647 Datum
3649 {
3651 Name result;
3656 /* Truncate oversize input */
3660 /* We use palloc0 here to ensure result is zero-padded */
3665 }
3667 /* name_text()
3668 * Converts a Name type to a text type.
3669 */
3670 Datum
3672 {
3676 }
3679 /*
3680 * textToQualifiedNameList - convert a text object to list of names
3681 *
3682 * This implements the input parsing needed by nextval() and other
3683 * functions that take a text parameter representing a qualified name.
3684 * We split the name at dots, downcase if not double-quoted, and
3685 * truncate names if they're too long.
3686 */
3687 List *
3689 {
3695 /* Convert to C string (handles possible detoasting). */
3696 /* Note we rely on being able to modify rawname below. */
3710 {
3714 }
3720 }
3722 /*
3723 * SplitIdentifierString --- parse a string containing identifiers
3724 *
3725 * This is the guts of textToQualifiedNameList, and is exported for use in
3726 * other situations such as parsing GUC variables. In the GUC case, it's
3727 * important to avoid memory leaks, so the API is designed to minimize the
3728 * amount of stuff that needs to be allocated and freed.
3729 *
3730 * Inputs:
3731 * rawstring: the input string; must be overwritable! On return, it's
3732 * been modified to contain the separated identifiers.
3733 * separator: the separator punctuation expected between identifiers
3734 * (typically '.' or ','). Whitespace may also appear around
3735 * identifiers.
3736 * Outputs:
3737 * namelist: filled with a palloc'd list of pointers to identifiers within
3738 * rawstring. Caller should list_free() this even on error return.
3739 *
3740 * Returns true if okay, false if there is a syntax error in the string.
3741 *
3742 * Note that an empty string is considered okay here, though not in
3743 * textToQualifiedNameList.
3744 */
3745 bool
3748 {
3760 /* At the top of the loop, we are at start of a new identifier. */
3761 do
3762 {
3767 {
3768 /* Quoted name --- collapse quote-quote pairs, no downcasing */
3771 {
3777 /* Collapse adjacent quotes into one quote, and look again */
3780 }
3781 /* endp now points at the terminating quote */
3783 }
3784 else
3785 {
3786 /* Unquoted name --- extends to separator or whitespace */
3793 nextp++;
3798 /*
3799 * Downcase the identifier, using same code as main lexer does.
3800 *
3801 * XXX because we want to overwrite the input in-place, we cannot
3802 * support a downcasing transformation that increases the string
3803 * length. This is not a problem given the current implementation
3804 * of downcase_truncate_identifier, but we'll probably have to do
3805 * something about this someday.
3806 */
3812 }
3818 {
3819 nextp++;
3822 /* we expect another name, so done remains false */
3823 }
3826 else
3829 /* Now safe to overwrite separator with a null */
3832 /* Truncate name if it's overlength */
3835 /*
3836 * Finished isolating current name --- add it to list
3837 */
3840 /* Loop back if we didn't reach end of string */
3844 }
3847 /*
3848 * SplitDirectoriesString --- parse a string containing file/directory names
3849 *
3850 * This works fine on file names too; the function name is historical.
3851 *
3852 * This is similar to SplitIdentifierString, except that the parsing
3853 * rules are meant to handle pathnames instead of identifiers: there is
3854 * no downcasing, embedded spaces are allowed, the max length is MAXPGPATH-1,
3855 * and we apply canonicalize_path() to each extracted string. Because of the
3856 * last, the returned strings are separately palloc'd rather than being
3857 * pointers into rawstring --- but we still scribble on rawstring.
3858 *
3859 * Inputs:
3860 * rawstring: the input string; must be modifiable!
3861 * separator: the separator punctuation expected between directories
3862 * (typically ',' or ';'). Whitespace may also appear around
3863 * directories.
3864 * Outputs:
3865 * namelist: filled with a palloc'd list of directory names.
3866 * Caller should list_free_deep() this even on error return.
3867 *
3868 * Returns true if okay, false if there is a syntax error in the string.
3869 *
3870 * Note that an empty string is considered okay here.
3871 */
3872 bool
3875 {
3887 /* At the top of the loop, we are at start of a new directory. */
3888 do
3889 {
3894 {
3895 /* Quoted name --- collapse quote-quote pairs */
3898 {
3904 /* Collapse adjacent quotes into one quote, and look again */
3907 }
3908 /* endp now points at the terminating quote */
3910 }
3911 else
3912 {
3913 /* Unquoted name --- extends to separator or end of string */
3916 {
3917 /* trailing whitespace should not be included in name */
3920 nextp++;
3921 }
3924 }
3930 {
3931 nextp++;
3934 /* we expect another name, so done remains false */
3935 }
3938 else
3941 /* Now safe to overwrite separator with a null */
3944 /* Truncate path if it's overlength */
3948 /*
3949 * Finished isolating current name --- add it to list
3950 */
3955 /* Loop back if we didn't reach end of string */
3959 }
3962 /*
3963 * SplitGUCList --- parse a string containing identifiers or file names
3964 *
3965 * This is used to split the value of a GUC_LIST_QUOTE GUC variable, without
3966 * presuming whether the elements will be taken as identifiers or file names.
3967 * We assume the input has already been through flatten_set_variable_args(),
3968 * so that we need never downcase (if appropriate, that was done already).
3969 * Nor do we ever truncate, since we don't know the correct max length.
3970 * We disallow embedded whitespace for simplicity (it shouldn't matter,
3971 * because any embedded whitespace should have led to double-quoting).
3972 * Otherwise the API is identical to SplitIdentifierString.
3973 *
3974 * XXX it's annoying to have so many copies of this string-splitting logic.
3975 * However, it's not clear that having one function with a bunch of option
3976 * flags would be much better.
3977 *
3978 * XXX there is a version of this function in src/bin/pg_dump/dumputils.c.
3979 * Be sure to update that if you have to change this.
3980 *
3981 * Inputs:
3982 * rawstring: the input string; must be overwritable! On return, it's
3983 * been modified to contain the separated identifiers.
3984 * separator: the separator punctuation expected between identifiers
3985 * (typically '.' or ','). Whitespace may also appear around
3986 * identifiers.
3987 * Outputs:
3988 * namelist: filled with a palloc'd list of pointers to identifiers within
3989 * rawstring. Caller should list_free() this even on error return.
3990 *
3991 * Returns true if okay, false if there is a syntax error in the string.
3992 */
3993 bool
3996 {
4008 /* At the top of the loop, we are at start of a new identifier. */
4009 do
4010 {
4015 {
4016 /* Quoted name --- collapse quote-quote pairs */
4019 {
4025 /* Collapse adjacent quotes into one quote, and look again */
4028 }
4029 /* endp now points at the terminating quote */
4031 }
4032 else
4033 {
4034 /* Unquoted name --- extends to separator or whitespace */
4038 nextp++;
4042 }
4048 {
4049 nextp++;
4052 /* we expect another name, so done remains false */
4053 }
4056 else
4059 /* Now safe to overwrite separator with a null */
4062 /*
4063 * Finished isolating current name --- add it to list
4064 */
4067 /* Loop back if we didn't reach end of string */
4071 }
4074 /*****************************************************************************
4075 * Comparison Functions used for bytea
4076 *
4077 * Note: btree indexes need these routines not to leak memory; therefore,
4078 * be careful to free working copies of toasted datums. Most places don't
4079 * need to be so careful.
4080 *****************************************************************************/
4082 Datum
4084 {
4088 Size len1,
4089 len2;
4091 /*
4092 * We can use a fast path for unequal lengths, which might save us from
4093 * having to detoast one or both values.
4094 */
4099 else
4100 {
4109 }
4112 }
4114 Datum
4116 {
4120 Size len1,
4121 len2;
4123 /*
4124 * We can use a fast path for unequal lengths, which might save us from
4125 * having to detoast one or both values.
4126 */
4131 else
4132 {
4141 }
4144 }
4146 Datum
4148 {
4152 len2;
4164 }
4166 Datum
4168 {
4172 len2;
4184 }
4186 Datum
4188 {
4192 len2;
4204 }
4206 Datum
4208 {
4212 len2;
4224 }
4226 Datum
4228 {
4232 len2;
4246 }
4248 Datum
4250 {
4252 MemoryContext oldcontext;
4256 /* Use generic string SortSupport, forcing "C" collation */
4262 }
4264 /*
4265 * appendStringInfoText
4266 *
4267 * Append a text to str.
4268 * Like appendStringInfoString(str, text_to_cstring(t)) but faster.
4269 */
4270 static void
4272 {
4274 }
4276 /*
4277 * replace_text
4278 * replace all occurrences of 'old_sub_str' in 'orig_str'
4279 * with 'new_sub_str' to form 'new_str'
4280 *
4281 * returns 'orig_str' if 'old_sub_str' == '' or 'orig_str' == ''
4282 * otherwise returns 'new_str'
4283 */
4284 Datum
4286 {
4292 TextPositionState state;
4297 StringInfoData str;
4303 /* Return unmodified source string if empty source or pattern */
4305 {
4307 }
4313 /* When the from_sub_text is not found, there is nothing to do. */
4315 {
4318 }
4324 do
4325 {
4328 /* copy the data skipped over by last text_position_next() */
4339 }
4342 /* copy trailing data */
4352 }
4354 /*
4355 * check_replace_text_has_escape
4356 *
4357 * Returns 0 if text contains no backslashes that need processing.
4358 * Returns 1 if text contains backslashes, but not regexp submatch specifiers.
4359 * Returns 2 if text contains regexp submatch specifiers (\1 .. \9).
4360 */
4361 static int
4363 {
4369 {
4370 /* Find next escape char, if any. */
4374 p++;
4375 /* Note: a backslash at the end doesn't require extra processing. */
4377 {
4381 p++;
4382 }
4383 }
4385 }
4387 /*
4388 * appendStringInfoRegexpSubstr
4389 *
4390 * Append replace_text to str, substituting regexp back references for
4391 * \n escapes. start_ptr is the start of the match in the source string,
4392 * at logical character position data_pos.
4393 */
4394 static void
4398 {
4403 {
4408 /* Find next escape char, if any. */
4413 /* Copy the text we just scanned over, if any. */
4417 /* Done if at end of string, else advance over escape char. */
4420 p++;
4423 {
4424 /* Escape at very end of input. Treat same as unexpected char */
4427 }
4430 {
4431 /* Use the back reference of regexp. */
4436 p++;
4437 }
4439 {
4440 /* Use the entire matched string. */
4443 p++;
4444 }
4446 {
4447 /* \\ means transfer one \ to output. */
4449 p++;
4451 }
4452 else
4453 {
4454 /*
4455 * If escape char is not followed by any expected char, just treat
4456 * it as ordinary data to copy. (XXX would it be better to throw
4457 * an error?)
4458 */
4461 }
4464 {
4465 /*
4466 * Copy the text that is back reference of regexp. Note so and eo
4467 * are counted in characters not bytes.
4468 */
4477 }
4478 }
4479 }
4481 /*
4482 * replace_text_regexp
4483 *
4484 * replace substring(s) in src_text that match pattern with replace_text.
4485 * The replace_text can contain backslash markers to substitute
4486 * (parts of) the matched text.
4487 *
4488 * cflags: regexp compile flags.
4489 * collation: collation to use.
4490 * search_start: the character (not byte) offset in src_text at which to
4491 * begin searching.
4492 * n: if 0, replace all matches; if > 0, replace only the N'th match.
4493 */
4494 text *
4499 {
4504 StringInfoData buf;
4515 /* Convert data string to wide characters. */
4519 /* Check whether replace_text has escapes, especially regexp submatches. */
4522 /* If no regexp submatches, we can use REG_NOSUB. */
4524 {
4526 /* Also tell pg_regexec we only want the whole-match location. */
4528 }
4530 /* Prepare the regexp. */
4533 /* start_ptr points to the data_pos'th character of src_text */
4538 {
4544 data,
4545 data_len,
4546 search_start,
4548 nmatch,
4549 pmatch,
4556 {
4564 }
4566 /*
4567 * Count matches, and decide whether to replace this match.
4568 */
4569 nmatches++;
4571 {
4572 /*
4573 * No, so advance search_start, but not start_ptr/data_pos. (Thus,
4574 * we treat the matched text as if it weren't matched, and copy it
4575 * to the output later.)
4576 */
4579 search_start++;
4581 }
4583 /*
4584 * Copy the text to the left of the match position. Note we are given
4585 * character not byte indexes.
4586 */
4588 {
4595 /*
4596 * Advance start_ptr over that text, to avoid multiple rescans of
4597 * it if the replace_text contains multiple back-references.
4598 */
4601 }
4603 /*
4604 * Copy the replace_text, processing escapes if any are present.
4605 */
4609 else
4612 /* Advance start_ptr and data_pos over the matched text. */
4617 /*
4618 * If we only want to replace one occurrence, we're done.
4619 */
4623 /*
4624 * Advance search position. Normally we start the next search at the
4625 * end of the previous match; but if the match was of zero length, we
4626 * have to advance by one character, or we'd just find the same match
4627 * again.
4628 */
4631 search_start++;
4632 }
4634 /*
4635 * Copy the text to the right of the last match.
4636 */
4638 {
4643 }
4650 }
4652 /*
4653 * split_part
4654 * parse input string based on provided field separator
4655 * return N'th item (1 based, negative counts from end)
4656 */
4657 Datum
4659 {
4665 TextPositionState state;
4671 /* field number is 1 based */
4680 /* return empty string for empty input string */
4684 /* handle empty field separator */
4686 {
4687 /* if first or last field, return input string, else empty string */
4690 else
4692 }
4694 /* find the first field separator */
4699 /* special case if fldsep not found at all */
4701 {
4703 /* if first or last field, return input string, else empty string */
4706 else
4708 }
4710 /*
4711 * take care of a negative field number (i.e. count from the right) by
4712 * converting to a positive field number; we need total number of fields
4713 */
4715 {
4716 /* we found a fldsep, so there are at least two fields */
4720 numfields++;
4722 /* special case of last field does not require an extra pass */
4724 {
4730 }
4732 /* else, convert fldnum to positive notation */
4735 /* if nonexistent field, return empty string */
4737 {
4740 }
4742 /* reset to pointing at first match, but now with positive fldnum */
4746 }
4748 /* identify bounds of first field */
4753 {
4754 /* identify bounds of next field */
4759 }
4764 {
4765 /* N'th field separator not found */
4766 /* if last field requested, return it, else empty string */
4768 {
4773 }
4774 else
4776 }
4777 else
4778 {
4779 /* non-last field requested */
4781 }
4784 }
4786 /*
4787 * Convenience function to return true when two text params are equal.
4788 */
4789 static bool
4791 {
4793 collid,
4796 }
4798 /*
4799 * text_to_array
4800 * parse input string and return text array of elements,
4801 * based on provided field separator
4802 */
4803 Datum
4805 {
4806 SplitTextOutputData tstate;
4808 /* For array output, tstate should start as all zeroes */
4818 CurrentMemoryContext));
4819 }
4821 /*
4822 * text_to_array_null
4823 * parse input string and return text array of elements,
4824 * based on provided field separator and null string
4825 *
4826 * This is a separate entry point only to prevent the regression tests from
4827 * complaining about different argument sets for the same internal function.
4828 */
4829 Datum
4831 {
4833 }
4835 /*
4836 * text_to_table
4837 * parse input string and return table of elements,
4838 * based on provided field separator
4839 */
4840 Datum
4842 {
4844 SplitTextOutputData tstate;
4845 MemoryContext old_cxt;
4847 /* check to see if caller supports us returning a tuplestore */
4857 /* OK, prepare tuplestore in per-query memory */
4875 }
4877 /*
4878 * text_to_table_null
4879 * parse input string and return table of elements,
4880 * based on provided field separator and null string
4881 *
4882 * This is a separate entry point only to prevent the regression tests from
4883 * complaining about different argument sets for the same internal function.
4884 */
4885 Datum
4887 {
4889 }
4891 /*
4892 * Common code for text_to_array, text_to_array_null, text_to_table
4893 * and text_to_table_null functions.
4894 *
4895 * These are not strict so we have to test for null inputs explicitly.
4896 * Returns false if result is to be null, else returns true.
4897 *
4898 * Note that if the result is valid but empty (zero elements), we return
4899 * without changing *tstate --- caller must handle that case, too.
4900 */
4901 static bool
4903 {
4913 /* when input string is NULL, then result is NULL too */
4919 /* fldsep can be NULL */
4922 else
4925 /* null_string can be NULL or omitted */
4928 else
4932 {
4933 /*
4934 * Normal case with non-null fldsep. Use the text_position machinery
4935 * to search for occurrences of fldsep.
4936 */
4937 TextPositionState state;
4942 /* return empty set for empty input string */
4946 /* empty field separator: return input string as a one-element set */
4948 {
4952 }
4959 {
4968 {
4969 /* fetch last field */
4972 }
4973 else
4974 {
4975 /* fetch non-last field */
4978 }
4980 /* build a temp text datum to pass to split_text_accum_result */
4983 /* stash away this field */
4993 }
4996 }
4997 else
4998 {
4999 /*
5000 * When fldsep is NULL, each character in the input string becomes a
5001 * separate element in the result set. The separator is effectively
5002 * the space between characters.
5003 */
5009 {
5014 /* build a temp text datum to pass to split_text_accum_result */
5017 /* stash away this field */
5025 }
5026 }
5029 }
5031 /*
5032 * Add text item to result set (table or array).
5033 *
5034 * This is also responsible for checking to see if the item matches
5035 * the null_string, in which case we should emit NULL instead.
5036 */
5037 static void
5041 Oid collation)
5042 {
5049 {
5058 values,
5059 nulls);
5060 }
5061 else
5062 {
5065 is_null,
5066 TEXTOID,
5067 CurrentMemoryContext);
5068 }
5069 }
5071 /*
5072 * array_to_text
5073 * concatenate Cstring representation of input array elements
5074 * using provided field separator
5075 */
5076 Datum
5078 {
5083 }
5085 /*
5086 * array_to_text_null
5087 * concatenate Cstring representation of input array elements
5088 * using provided field separator and null string
5089 *
5090 * This version is not strict so we have to test for null inputs explicitly.
5091 */
5092 Datum
5094 {
5099 /* returns NULL when first or second parameter is NULL */
5106 /* NULL null string is passed through as a null pointer */
5109 else
5113 }
5115 /*
5116 * common code for array_to_text and array_to_text_null functions
5117 */
5121 {
5125 ndims;
5126 Oid element_type;
5130 StringInfoData buf;
5142 /* if there are no elements, return an empty string */
5149 /*
5150 * We arrange to look up info about element type, including its output
5151 * conversion proc, only once per series of calls, assuming the element
5152 * type doesn't change underneath us.
5153 */
5156 {
5161 }
5164 {
5165 /*
5166 * Get info about element type, including its output conversion proc
5167 */
5175 }
5185 {
5186 Datum itemvalue;
5189 /* Get source element, checking for NULL */
5191 {
5192 /* if null_string is NULL, we just ignore null elements */
5194 {
5197 else
5200 }
5201 }
5202 else
5203 {
5210 else
5216 }
5218 /* advance bitmap pointer if any */
5220 {
5223 {
5224 bitmap++;
5226 }
5227 }
5228 }
5234 }
5236 #define HEXBASE 16
5237 /*
5238 * Convert an int32 to a string containing a base 16 (hex) representation of
5239 * the number.
5240 */
5241 Datum
5243 {
5252 do
5253 {
5259 }
5261 /*
5262 * Convert an int64 to a string containing a base 16 (hex) representation of
5263 * the number.
5264 */
5265 Datum
5267 {
5276 do
5277 {
5283 }
5285 /*
5286 * Return the size of a datum, possibly compressed
5287 *
5288 * Works on any data type
5289 */
5290 Datum
5292 {
5294 int32 result;
5297 /* On first call, get the input type's typlen, and save at *fn_extra */
5299 {
5300 /* Lookup the datatype of the supplied argument */
5310 }
5311 else
5315 {
5316 /* varlena type, possibly toasted */
5318 }
5320 {
5321 /* cstring */
5323 }
5324 else
5325 {
5326 /* ordinary fixed-width type */
5328 }
5331 }
5333 /*
5334 * Return the compression method stored in the compressed attribute. Return
5335 * NULL for non varlena type or uncompressed data.
5336 */
5337 Datum
5339 {
5342 ToastCompressionId cmid;
5344 /* On first call, get the input type's typlen, and save at *fn_extra */
5346 {
5347 /* Lookup the datatype of the supplied argument */
5357 }
5358 else
5364 /* get the compression method id stored in the compressed varlena */
5370 /* convert compression method id to compression method name */
5372 {
5381 }
5384 }
5386 /*
5387 * string_agg - Concatenates values and returns string.
5388 *
5389 * Syntax: string_agg(value text, delimiter text) RETURNS text
5390 *
5391 * Note: Any NULL values are ignored. The first-call delimiter isn't
5392 * actually used at all, and on subsequent calls the delimiter precedes
5393 * the associated value.
5394 */
5396 /* subroutine to initialize state */
5397 static StringInfo
5399 {
5400 StringInfo state;
5401 MemoryContext aggcontext;
5402 MemoryContext oldcontext;
5405 {
5406 /* cannot be called directly because of internal-type argument */
5408 }
5410 /*
5411 * Create state in aggregate context. It'll stay there across subsequent
5412 * calls.
5413 */
5419 }
5421 Datum
5423 {
5424 StringInfo state;
5428 /* Append the value unless null. */
5430 {
5431 /* On the first time through, we ignore the delimiter. */
5438 }
5440 /*
5441 * The transition type for string_agg() is declared to be "internal",
5442 * which is a pass-by-value type the same size as a pointer.
5443 */
5445 }
5447 Datum
5449 {
5450 StringInfo state;
5452 /* cannot be called directly because of internal-type argument */
5459 else
5461 }
5463 /*
5464 * Prepare cache with fmgr info for the output functions of the datatypes of
5465 * the arguments of a concat-like function, beginning with argument "argidx".
5466 * (Arguments before that will have corresponding slots in the resulting
5467 * FmgrInfo array, but we don't fill those slots.)
5468 */
5471 {
5475 /* We keep the info in fn_mcxt so it survives across calls */
5480 {
5481 Oid valtype;
5482 Oid typOutput;
5491 }
5496 }
5498 /*
5499 * Implementation of both concat() and concat_ws().
5500 *
5501 * sepstr is the separator string to place between values.
5502 * argidx identifies the first argument to concatenate (counting from zero);
5503 * note that this must be constant across any one series of calls.
5504 *
5505 * Returns NULL if result should be NULL, else text value.
5506 */
5509 FunctionCallInfo fcinfo)
5510 {
5512 StringInfoData str;
5517 /*
5518 * concat(VARIADIC some-array) is essentially equivalent to
5519 * array_to_text(), ie concat the array elements with the given separator.
5520 * So we just pass the case off to that code.
5521 */
5523 {
5526 /* Should have just the one argument */
5529 /* concat(VARIADIC NULL) is defined as NULL */
5533 /*
5534 * Non-null argument had better be an array. We assume that any call
5535 * context that could let get_fn_expr_variadic return true will have
5536 * checked that a VARIADIC-labeled parameter actually is an array. So
5537 * it should be okay to just Assert that it's an array rather than
5538 * doing a full-fledged error check.
5539 */
5542 /* OK, safe to fetch the array value */
5545 /*
5546 * And serialize the array. We tell array_to_text to ignore null
5547 * elements, which matches the behavior of the loop below.
5548 */
5550 }
5552 /* Normal case without explicit VARIADIC marker */
5555 /* Get output function info, building it if first time through */
5561 {
5563 {
5566 /* add separator if appropriate */
5569 else
5572 /* call the appropriate type output function, append the result */
5575 }
5576 }
5582 }
5584 /*
5585 * Concatenate all arguments. NULL arguments are ignored.
5586 */
5587 Datum
5589 {
5596 }
5598 /*
5599 * Concatenate all but first argument value with separators. The first
5600 * parameter is used as the separator. NULL arguments are ignored.
5601 */
5602 Datum
5604 {
5608 /* return NULL when separator is NULL */
5617 }
5619 /*
5620 * Return first n characters in the string. When n is negative,
5621 * return all but last |n| characters.
5622 */
5623 Datum
5625 {
5629 {
5638 }
5639 else
5641 }
5643 /*
5644 * Return last n characters in the string. When n is negative,
5645 * return all but first |n| characters.
5646 */
5647 Datum
5649 {
5658 else
5663 }
5665 /*
5666 * Return reversed string
5667 */
5668 Datum
5670 {
5683 {
5684 /* multibyte version */
5686 {
5693 }
5694 }
5695 else
5696 {
5697 /* single byte version */
5700 }
5703 }
5706 /*
5707 * Support macros for text_format()
5708 */
5711 #define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
5712 do { \
5713 if (++(ptr) >= (end_ptr)) \
5714 ereport(ERROR, \
5715 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
5718 } while (0)
5720 /*
5721 * Returns a formatted string
5722 */
5723 Datum
5725 {
5727 StringInfoData str;
5740 FmgrInfo typoutputfinfo;
5741 FmgrInfo typoutputinfo_width;
5743 /* When format string is null, immediately return null */
5747 /* If argument is marked VARIADIC, expand array into elements */
5749 {
5751 int16 elmlen;
5756 /* Should have just the one argument */
5759 /* If argument is NULL, we treat it as zero-length array */
5762 else
5763 {
5764 /*
5765 * Non-null argument had better be an array. We assume that any
5766 * call context that could let get_fn_expr_variadic return true
5767 * will have checked that a VARIADIC-labeled parameter actually is
5768 * an array. So it should be okay to just Assert that it's an
5769 * array rather than doing a full-fledged error check.
5770 */
5773 /* OK, safe to fetch the array value */
5776 /* Get info about array element type */
5781 /* Extract all array elements */
5784 }
5788 }
5789 else
5790 {
5791 /* Non-variadic case, we'll process the arguments individually */
5794 }
5796 /* Setup for main loop. */
5803 /* Scan format string, looking for conversion specifiers. */
5805 {
5810 Datum value;
5812 Oid typid;
5814 /*
5815 * If it's not the start of a conversion specifier, just copy it to
5816 * the output buffer.
5817 */
5819 {
5822 }
5826 /* Easy case: %% outputs a single % */
5828 {
5831 }
5833 /* Parse the optional portions of the format specifier */
5838 /*
5839 * Next we should see the main conversion specifier. Whether or not
5840 * an argument position was present, it's known that at least one
5841 * character remains in the string at this point. Experience suggests
5842 * that it's worth checking that that character is one of the expected
5843 * ones before we try to fetch arguments, so as to produce the least
5844 * confusing response to a mis-formatted specifier.
5845 */
5853 /* If indirect width was specified, get its value */
5855 {
5856 /* Collect the specified or next argument position */
5864 /* Get the value and type of the selected argument */
5866 {
5870 }
5871 else
5872 {
5876 }
5880 arg++;
5882 /* We can treat NULL width the same as zero */
5889 else
5890 {
5891 /* For less-usual datatypes, convert to text then to int */
5895 {
5896 Oid typoutputfunc;
5902 }
5906 /* pg_strtoint32 will complain about bad data or overflow */
5910 }
5911 }
5913 /* Collect the specified or next argument position */
5921 /* Get the value and type of the selected argument */
5923 {
5927 }
5928 else
5929 {
5933 }
5937 arg++;
5939 /*
5940 * Get the appropriate typOutput function, reusing previous one if
5941 * same type as previous argument. That's particularly useful in the
5942 * variadic-array case, but often saves work even for ordinary calls.
5943 */
5945 {
5946 Oid typoutputfunc;
5952 }
5954 /*
5955 * And now we can format the value.
5956 */
5958 {
5967 /* should not get here, because of previous check */
5974 }
5975 }
5977 /* Don't need deconstruct_array results anymore. */
5983 /* Generate results. */
5988 }
5990 /*
5991 * Parse contiguous digits as a decimal number.
5992 *
5993 * Returns true if some digits could be parsed.
5994 * The value is returned into *value, and *ptr is advanced to the next
5995 * character to be parsed.
5996 *
5997 * Note parsing invariant: at least one character is known available before
5998 * string end (end_ptr) at entry, and this is still true at exit.
5999 */
6000 static bool
6002 {
6008 {
6018 }
6024 }
6026 /*
6027 * Parse a format specifier (generally following the SUS printf spec).
6028 *
6029 * We have already advanced over the initial '%', and we are looking for
6030 * [argpos][flags][width]type (but the type character is not consumed here).
6031 *
6032 * Inputs are start_ptr (the position after '%') and end_ptr (string end + 1).
6033 * Output parameters:
6034 * argpos: argument position for value to be printed. -1 means unspecified.
6035 * widthpos: argument position for width. Zero means the argument position
6036 * was unspecified (ie, take the next arg) and -1 means no width
6037 * argument (width was omitted or specified as a constant).
6038 * flags: bitmask of flags.
6039 * width: directly-specified width value. Zero means the width was omitted
6040 * (note it's not necessary to distinguish this case from an explicit
6041 * zero width value).
6042 *
6043 * The function result is the next character position to be parsed, ie, the
6044 * location where the type character is/should be.
6045 *
6046 * Note parsing invariant: at least one character is known available before
6047 * string end (end_ptr) at entry, and this is still true at exit.
6048 */
6053 {
6057 /* set defaults for output parameters */
6063 /* try to identify first number */
6065 {
6067 {
6068 /* Must be just a width and a type, so we're done */
6071 }
6072 /* The number was argument position */
6074 /* Explicit 0 for argument index is immediately refused */
6080 }
6082 /* Handle flags (only minus is supported now) */
6084 {
6087 }
6090 {
6091 /* Handle indirect width */
6094 {
6095 /* number in this position must be closed by $ */
6100 /* The number was width argument position */
6102 /* Explicit 0 for argument index is immediately refused */
6108 }
6109 else
6111 }
6112 else
6113 {
6114 /* Check for direct width specification */
6117 }
6119 /* cp should now be pointing at type character */
6121 }
6123 /*
6124 * Format a %s, %I, or %L conversion
6125 */
6126 static void
6131 {
6134 /* Handle NULL arguments before trying to stringify the value. */
6136 {
6146 }
6148 /* Stringify. */
6151 /* Escape. */
6153 {
6154 /* quote_identifier may or may not allocate a new string. */
6156 }
6158 {
6162 /* quote_literal_cstr() always allocates a new string */
6164 }
6165 else
6168 /* Cleanup. */
6170 }
6172 /*
6173 * Append str to buf, padding as directed by flags/width
6174 */
6175 static void
6178 {
6182 /* fast path for typical easy case */
6184 {
6187 }
6190 {
6191 /* Negative width: implicit '-' flag, then take absolute value */
6193 /* -INT_MIN is undefined */
6199 }
6205 {
6206 /* left justify */
6210 }
6211 else
6212 {
6213 /* right justify */
6217 }
6218 }
6220 /*
6221 * text_format_nv - nonvariadic wrapper for text_format function.
6222 *
6223 * note: this wrapper is necessary to pass the sanity check in opr_sanity,
6224 * which checks that all built-in functions that share the implementing C
6225 * function take the same number of arguments.
6226 */
6227 Datum
6229 {
6231 }
6233 /*
6234 * Helper function for Levenshtein distance functions. Faster than memcmp(),
6235 * for this use case.
6236 */
6239 {
6241 {
6242 len--;
6245 }
6247 }
6249 /* Expand each Levenshtein distance variant */
6251 #define LEVENSHTEIN_LESS_EQUAL
6255 /*
6256 * Unicode support
6257 */
6259 static UnicodeNormalizationForm
6261 {
6264 /*
6265 * Might as well check this while we're here.
6266 */
6280 else
6286 }
6288 Datum
6290 {
6293 UnicodeNormalizationForm form;
6303 /* convert to pg_wchar */
6308 {
6311 }
6315 /* action */
6318 /* convert back to UTF-8 string */
6321 {
6326 }
6333 {
6336 }
6340 }
6342 /*
6343 * Check whether the string is in the specified Unicode normalization form.
6344 *
6345 * This is done by converting the string to the specified normal form and then
6346 * comparing that to the original string. To speed that up, we also apply the
6347 * "quick check" algorithm specified in UAX #15, which can give a yes or no
6348 * answer for many strings by just scanning the string once.
6349 *
6350 * This function should generally be optimized for the case where the string
6351 * is in fact normalized. In that case, we'll end up looking at the entire
6352 * string, so it's probably not worth doing any incremental conversion etc.
6353 */
6354 Datum
6356 {
6359 UnicodeNormalizationForm form;
6365 UnicodeNormalizationQC quickcheck;
6371 /* convert to pg_wchar */
6376 {
6379 }
6383 /* quick check (see UAX #15) */
6390 /* normalize and compare with original */
6395 output_size++;
6401 }
6403 /*
6404 * Check if first n chars are hexadecimal digits
6405 */
6406 static bool
6408 {
6414 }
6416 static unsigned int
6418 {
6427 }
6429 /*
6430 * Translate string with hexadecimal digits to number
6431 */
6432 static unsigned int
6434 {
6441 }
6443 /*
6444 * Replaces Unicode escape sequences by Unicode characters
6445 */
6446 Datum
6448 {
6452 StringInfoData str;
6463 {
6465 {
6468 {
6474 }
6477 {
6478 pg_wchar unicode;
6489 {
6491 {
6494 }
6495 else
6497 }
6503 else
6504 {
6507 }
6511 }
6513 {
6514 pg_wchar unicode;
6524 {
6526 {
6529 }
6530 else
6532 }
6538 else
6539 {
6542 }
6546 }
6548 {
6549 pg_wchar unicode;
6559 {
6561 {
6564 }
6565 else
6567 }
6573 else
6574 {
6577 }
6581 }
6582 else
6587 }
6588 else
6589 {
6594 len--;
6595 }
6596 }
6598 /* unfinished surrogate pair? */
6607 invalid_pair:
6612 }