| blob | 1c52deec556aab2f8a9f3e3aafc73219c08a36d8 |
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>
45 /* GUC variable */
51 /*
52 * State for text_position_* functions.
53 */
55 {
63 /* Skip table for Boyer-Moore-Horspool search algorithm: */
69 /*
70 * Sometimes we need to convert the byte position of a match to a
71 * character position. These store the last position that was converted,
72 * so that on the next call, we can continue from that point, rather than
73 * count characters from the very beginning.
74 */
80 {
82 * buf */
95 pg_locale_t locale;
98 /*
99 * Output data for split_text(): we output either to an array or a table.
100 * tupstore and tupdesc must be set up in advance to output to a table.
101 */
103 {
106 TupleDesc tupdesc;
109 /*
110 * This should be large enough that most strings will fit, but small enough
111 * that we feel comfortable putting it on the stack
112 */
113 #define TEXTBUFLEN 1024
115 #define DatumGetUnknownP(X) ((unknown *) PG_DETOAST_DATUM(X))
116 #define DatumGetUnknownPCopy(X) ((unknown *) PG_DETOAST_DATUM_COPY(X))
117 #define PG_GETARG_UNKNOWN_P(n) DatumGetUnknownP(PG_GETARG_DATUM(n))
118 #define PG_GETARG_UNKNOWN_P_COPY(n) DatumGetUnknownPCopy(PG_GETARG_DATUM(n))
119 #define PG_RETURN_UNKNOWN_P(x) PG_RETURN_POINTER(x)
121 #define DatumGetVarStringP(X) ((VarString *) PG_DETOAST_DATUM(X))
122 #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 {
304 /* Recognize hex input */
306 {
312 escontext);
316 }
318 /* Else, it's the traditional escaped style */
320 {
322 tp++;
331 else
332 {
333 /*
334 * one backslash, not followed by another or ### valid octal
335 */
339 }
340 }
350 {
357 {
365 }
368 {
371 }
372 else
373 {
374 /*
375 * We should never get here. The first pass should not allow it.
376 */
380 }
381 }
384 }
386 /*
387 * byteaout - converts to printable representation of byte array
388 *
389 * In the traditional escaped format, non-printable characters are
390 * printed as '\nnn' (octal) and '\' as '\\'.
391 */
392 Datum
394 {
400 {
401 /* Print hex format */
406 }
408 {
409 /* Print traditional escaped format */
411 uint64 len;
417 {
422 else
423 len++;
424 }
426 /*
427 * In principle len can't overflow uint32 if the input fit in 1GB, but
428 * for safety let's check rather than relying on palloc's internal
429 * check.
430 */
439 {
441 {
444 }
446 {
457 }
458 else
460 }
461 }
462 else
463 {
465 bytea_output);
467 }
470 }
472 /*
473 * bytearecv - converts external binary format to bytea
474 */
475 Datum
477 {
487 }
489 /*
490 * byteasend - converts bytea to binary format
491 *
492 * This is a special case: just copy the input...
493 */
494 Datum
496 {
500 }
502 Datum
504 {
505 StringInfo state;
509 /* Append the value unless null. */
511 {
514 /* On the first time through, we ignore the delimiter. */
518 {
522 }
525 }
527 /*
528 * The transition type for string_agg() is declared to be "internal",
529 * which is a pass-by-value type the same size as a pointer.
530 */
532 }
534 Datum
536 {
537 StringInfo state;
539 /* cannot be called directly because of internal-type argument */
545 {
552 }
553 else
555 }
557 /*
558 * textin - converts "..." to internal representation
559 */
560 Datum
562 {
566 }
568 /*
569 * textout - converts internal representation to "..."
570 */
571 Datum
573 {
577 }
579 /*
580 * textrecv - converts external binary format to text
581 */
582 Datum
584 {
595 }
597 /*
598 * textsend - converts text to binary format
599 */
600 Datum
602 {
604 StringInfoData buf;
609 }
612 /*
613 * unknownin - converts "..." to internal representation
614 */
615 Datum
617 {
620 /* representation is same as cstring */
622 }
624 /*
625 * unknownout - converts internal representation to "..."
626 */
627 Datum
629 {
630 /* representation is same as cstring */
634 }
636 /*
637 * unknownrecv - converts external binary format to unknown
638 */
639 Datum
641 {
647 /* representation is same as cstring */
649 }
651 /*
652 * unknownsend - converts unknown to binary format
653 */
654 Datum
656 {
657 /* representation is same as cstring */
659 StringInfoData buf;
664 }
667 /* ========== PUBLIC ROUTINES ========== */
669 /*
670 * textlen -
671 * returns the logical length of a text*
672 * (which is less than the VARSIZE of the text*)
673 */
674 Datum
676 {
679 /* try to avoid decompressing argument */
681 }
683 /*
684 * text_length -
685 * Does the real work for textlen()
686 *
687 * This is broken out so it can be called directly by other string processing
688 * functions. Note that the argument is passed as a Datum, to indicate that
689 * it may still be in compressed form. We can avoid decompressing it at all
690 * in some cases.
691 */
692 static int32
694 {
695 /* fastpath when max encoding length is one */
698 else
699 {
704 }
705 }
707 /*
708 * textoctetlen -
709 * returns the physical length of a text*
710 * (which is less than the VARSIZE of the text*)
711 */
712 Datum
714 {
717 /* We need not detoast the input at all */
719 }
721 /*
722 * textcat -
723 * takes two text* and returns a text* that is the concatenation of
724 * the two.
725 *
726 * Rewritten by Sapa, sapa@hq.icb.chel.su. 8-Jul-96.
727 * Updated by Thomas, Thomas.Lockhart@jpl.nasa.gov 1997-07-10.
728 * Allocate space for output in all cases.
729 * XXX - thomas 1997-07-10
730 */
731 Datum
733 {
738 }
740 /*
741 * text_catenate
742 * Guts of textcat(), broken out so it can be used by other functions
743 *
744 * Arguments can be in short-header form, but not compressed or out-of-line
745 */
748 {
751 len2,
752 len;
758 /* paranoia ... probably should throw error instead? */
767 /* Set size of result string... */
770 /* Fill data field of result string... */
778 }
780 /*
781 * charlen_to_bytelen()
782 * Compute the number of bytes occupied by n characters starting at *p
783 *
784 * It is caller's responsibility that there actually are n characters;
785 * the string need not be null-terminated.
786 */
787 static int
789 {
791 {
792 /* Optimization for single-byte encodings */
794 }
795 else
796 {
803 }
804 }
806 /*
807 * text_substr()
808 * Return a substring starting at the specified position.
809 * - thomas 1997-12-31
810 *
811 * Input:
812 * - string
813 * - starting position (is one-based)
814 * - string length
815 *
816 * If the starting position is zero or less, then return from the start of the string
817 * adjusting the length to be consistent with the "negative start" per SQL.
818 * If the length is less than zero, return the remaining string.
819 *
820 * Added multibyte support.
821 * - Tatsuo Ishii 1998-4-21
822 * Changed behavior if starting position is less than one to conform to SQL behavior.
823 * Formerly returned the entire string; now returns a portion.
824 * - Thomas Lockhart 1998-12-10
825 * Now uses faster TOAST-slicing interface
826 * - John Gray 2002-02-22
827 * Remove "#ifdef MULTIBYTE" and test for encoding_max_length instead. Change
828 * behaviors conflicting with SQL to meet SQL (if E = S + L < S throw
829 * error; if E < 1, return '', not entire string). Fixed MB related bug when
830 * S > LC and < LC + 4 sometimes garbage characters are returned.
831 * - Joe Conway 2002-08-10
832 */
833 Datum
835 {
840 }
842 /*
843 * text_substr_no_len -
844 * Wrapper to avoid opr_sanity failure due to
845 * one function accepting a different number of args.
846 */
847 Datum
849 {
853 }
855 /*
856 * text_substring -
857 * Does the real work for text_substr() and text_substr_no_len()
858 *
859 * This is broken out so it can be called directly by other string processing
860 * functions. Note that the argument is passed as a Datum, to indicate that
861 * it may still be in compressed/toasted form. We can avoid detoasting all
862 * of it in some cases.
863 *
864 * The result is always a freshly palloc'd datum.
865 */
868 {
875 /*
876 * SQL99 says S can be zero or negative, but we still must fetch from the
877 * start of the string.
878 */
881 /* life is easy if the encoding max length is 1 */
883 {
885 * string */
888 {
889 /* SQL99 says to throw an error for E < S, i.e., negative length */
894 }
896 {
897 /*
898 * L could be large enough for S + L to overflow, in which case
899 * the substring must run to end of string.
900 */
902 }
903 else
904 {
905 /*
906 * A zero or negative value for the end position can happen if the
907 * start was negative or one. SQL99 says to return a zero-length
908 * string.
909 */
914 }
916 /*
917 * If the start position is past the end of the string, SQL99 says to
918 * return a zero-length string -- DatumGetTextPSlice() will do that
919 * for us. We need only convert S1 to zero-based starting position.
920 */
922 }
924 {
925 /*
926 * When encoding max length is > 1, we can't get LC without
927 * detoasting, so we'll grab a conservatively large slice now and go
928 * back later to do the right thing
929 */
930 int32 slice_start;
931 int32 slice_size;
932 int32 slice_strlen;
934 int32 E1;
935 int32 i;
940 /*
941 * We need to start at position zero because there is no way to know
942 * in advance which byte offset corresponds to the supplied start
943 * position.
944 */
948 * string */
951 {
952 /* SQL99 says to throw an error for E < S, i.e., negative length */
957 }
959 {
960 /*
961 * L could be large enough for S + L to overflow, in which case
962 * the substring must run to end of string.
963 */
965 }
966 else
967 {
968 /*
969 * A zero or negative value for the end position can happen if the
970 * start was negative or one. SQL99 says to return a zero-length
971 * string.
972 */
976 /*
977 * if E is past the end of the string, the tuple toaster will
978 * truncate the length for us
979 */
982 /*
983 * Total slice size in bytes can't be any longer than the start
984 * position plus substring length times the encoding max length.
985 * If that overflows, we can just use -1.
986 */
989 }
991 /*
992 * If we're working with an untoasted source, no need to do an extra
993 * copying step.
994 */
998 else
1001 /* see if we got back an empty string */
1003 {
1007 }
1009 /* Now we can get the actual length of the slice in MB characters */
1013 /*
1014 * Check that the start position wasn't > slice_strlen. If so, SQL99
1015 * says to return a zero-length string.
1016 */
1018 {
1022 }
1024 /*
1025 * Adjust L1 and E1 now that we know the slice string length. Again
1026 * remember that S1 is one based, and slice_start is zero based.
1027 */
1030 else
1033 /*
1034 * Find the start position in the slice; remember S1 is not zero based
1035 */
1040 /* hang onto a pointer to our start position */
1043 /*
1044 * Count the actual bytes used by the substring of the requested
1045 * length.
1046 */
1058 }
1059 else
1062 /* not reached: suppress compiler warning */
1064 }
1066 /*
1067 * textoverlay
1068 * Replace specified substring of first string with second
1069 *
1070 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
1071 * This code is a direct implementation of what the standard says.
1072 */
1073 Datum
1075 {
1082 }
1084 Datum
1086 {
1094 }
1098 {
1104 /*
1105 * Check for possible integer-overflow cases. For negative sp, throw a
1106 * "substring length" error because that's what should be expected
1107 * according to the spec's definition of OVERLAY().
1108 */
1124 }
1126 /*
1127 * textpos -
1128 * Return the position of the specified substring.
1129 * Implements the SQL POSITION() function.
1130 * Ref: A Guide To The SQL Standard, Date & Darwen, 1997
1131 * - thomas 1997-07-27
1132 */
1133 Datum
1135 {
1140 }
1142 /*
1143 * text_position -
1144 * Does the real work for textpos()
1145 *
1146 * Inputs:
1147 * t1 - string to be searched
1148 * t2 - pattern to match within t1
1149 * Result:
1150 * Character index of the first matched char, starting from 1,
1151 * or 0 if no match.
1152 *
1153 * This is broken out so it can be called directly by other string processing
1154 * functions.
1155 */
1156 static int
1158 {
1159 TextPositionState state;
1162 /* Empty needle always matches at position 1 */
1166 /* Otherwise, can't match if haystack is shorter than needle */
1173 else
1177 }
1180 /*
1181 * text_position_setup, text_position_next, text_position_cleanup -
1182 * Component steps of text_position()
1183 *
1184 * These are broken out so that a string can be efficiently searched for
1185 * multiple occurrences of the same pattern. text_position_next may be
1186 * called multiple times, and it advances to the next match on each call.
1187 * text_position_get_match_ptr() and text_position_get_match_pos() return
1188 * a pointer or 1-based character position of the last match, respectively.
1189 *
1190 * The "state" variable is normally just a local variable in the caller.
1191 *
1192 * NOTE: text_position_next skips over the matched portion. For example,
1193 * searching for "xx" in "xxx" returns only one match, not two.
1194 */
1196 static void
1198 {
1216 /*
1217 * Even with a multi-byte encoding, we perform the search using the raw
1218 * byte sequence, ignoring multibyte issues. For UTF-8, that works fine,
1219 * because in UTF-8 the byte sequence of one character cannot contain
1220 * another character. For other multi-byte encodings, we do the search
1221 * initially as a simple byte search, ignoring multibyte issues, but
1222 * verify afterwards that the match we found is at a character boundary,
1223 * and continue the search if it was a false match.
1224 */
1229 else
1240 /*
1241 * Prepare the skip table for Boyer-Moore-Horspool searching. In these
1242 * notes we use the terminology that the "haystack" is the string to be
1243 * searched (t1) and the "needle" is the pattern being sought (t2).
1244 *
1245 * If the needle is empty or bigger than the haystack then there is no
1246 * point in wasting cycles initializing the table. We also choose not to
1247 * use B-M-H for needles of length 1, since the skip table can't possibly
1248 * save anything in that case.
1249 */
1251 {
1258 /*
1259 * First we must determine how much of the skip table to use. The
1260 * declaration of TextPositionState allows up to 256 elements, but for
1261 * short search problems we don't really want to have to initialize so
1262 * many elements --- it would take too long in comparison to the
1263 * actual search time. So we choose a useful skip table size based on
1264 * the haystack length minus the needle length. The closer the needle
1265 * length is to the haystack length the less useful skipping becomes.
1266 *
1267 * Note: since we use bit-masking to select table elements, the skip
1268 * table size MUST be a power of 2, and so the mask must be 2^N-1.
1269 */
1282 else
1286 /*
1287 * Initialize the skip table. We set all elements to the needle
1288 * length, since this is the correct skip distance for any character
1289 * not found in the needle.
1290 */
1294 /*
1295 * Now examine the needle. For each character except the last one,
1296 * set the corresponding table element to the appropriate skip
1297 * distance. Note that when two characters share the same skip table
1298 * entry, the one later in the needle must determine the skip
1299 * distance.
1300 */
1305 }
1306 }
1308 /*
1309 * Advance to the next match, starting from the end of the previous match
1310 * (or the beginning of the string, on first call). Returns true if a match
1311 * is found.
1312 *
1313 * Note that this refuses to match an empty-string needle. Most callers
1314 * will have handled that case specially and we'll never see it here.
1315 */
1316 static bool
1318 {
1326 /* Start from the point right after the previous match. */
1329 else
1332 retry:
1338 /*
1339 * Found a match for the byte sequence. If this is a multibyte encoding,
1340 * where one character's byte sequence can appear inside a longer
1341 * multi-byte character, we need to verify that the match was at a
1342 * character boundary, not in the middle of a multi-byte character.
1343 */
1345 {
1346 /* Walk one character at a time, until we reach the match. */
1348 /* the search should never move backwards. */
1352 {
1353 /* step to next character. */
1357 /*
1358 * If we stepped over the match's start position, then it was a
1359 * false positive, where the byte sequence appeared in the middle
1360 * of a multi-byte character. Skip it, and continue the search at
1361 * the next character boundary.
1362 */
1364 {
1367 }
1368 }
1369 }
1373 }
1375 /*
1376 * Subroutine of text_position_next(). This searches for the raw byte
1377 * sequence, ignoring any multi-byte encoding issues. Returns the first
1378 * match starting at 'start_ptr', or NULL if no match is found.
1379 */
1382 {
1394 {
1395 /* No point in using B-M-H for a one-character needle */
1400 {
1403 hptr++;
1404 }
1405 }
1406 else
1407 {
1410 /* Start at startpos plus the length of the needle */
1413 {
1414 /* Match the needle scanning *backward* */
1421 {
1422 /* Matched it all? If so, return 1-based position */
1426 }
1428 /*
1429 * No match, so use the haystack char at hptr to decide how far to
1430 * advance. If the needle had any occurrence of that character
1431 * (or more precisely, one sharing the same skiptable entry)
1432 * before its last character, then we advance far enough to align
1433 * the last such needle character with that haystack position.
1434 * Otherwise we can advance by the whole needle length.
1435 */
1437 }
1438 }
1441 }
1443 /*
1444 * Return a pointer to the current match.
1445 *
1446 * The returned pointer points into the original haystack string.
1447 */
1450 {
1452 }
1454 /*
1455 * Return the offset of the current match.
1456 *
1457 * The offset is in characters, 1-based.
1458 */
1459 static int
1461 {
1462 /* Convert the byte position to char position. */
1467 }
1469 /*
1470 * Reset search state to the initial state installed by text_position_setup.
1471 *
1472 * The next call to text_position_next will search from the beginning
1473 * of the string.
1474 */
1475 static void
1477 {
1481 }
1483 static void
1485 {
1486 /* no cleanup needed */
1487 }
1490 static void
1492 {
1494 {
1495 /*
1496 * This typically means that the parser could not resolve a conflict
1497 * of implicit collations, so report it that way.
1498 */
1503 }
1504 }
1506 /* varstr_cmp()
1507 * Comparison function for text strings with given lengths.
1508 * Includes locale support, but must copy strings to temporary memory
1509 * to allow null-termination for inputs to strcoll().
1510 * Returns an integer less than, equal to, or greater than zero, indicating
1511 * whether arg1 is less than, equal to, or greater than arg2.
1512 *
1513 * Note: many functions that depend on this are marked leakproof; therefore,
1514 * avoid reporting the actual contents of the input when throwing errors.
1515 * All errors herein should be things that can't happen except on corrupt
1516 * data, anyway; otherwise we will have trouble with indexing strings that
1517 * would cause them.
1518 */
1519 int
1521 {
1526 /*
1527 * Unfortunately, there is no strncoll(), so in the non-C locale case we
1528 * have to do some memory copying. This turns out to be significantly
1529 * slower, so we optimize the case where LC_COLLATE is C. We also try to
1530 * optimize relatively-short strings by avoiding palloc/pfree overhead.
1531 */
1533 {
1537 }
1538 else
1539 {
1544 pg_locale_t mylocale;
1548 /*
1549 * memcmp() can't tell us which of two unequal strings sorts first,
1550 * but it's a cheap way to tell if they're equal. Testing shows that
1551 * memcmp() followed by strcoll() is only trivially slower than
1552 * strcoll() by itself, so we don't lose much if this doesn't work out
1553 * very often, and if it does - for example, because there are many
1554 * equal strings in the input - then we win big by avoiding expensive
1555 * collation-aware comparisons.
1556 */
1560 #ifdef WIN32
1561 /* Win32 does not have UTF-8, so we need to map to UTF-16 */
1564 {
1570 {
1573 }
1574 else
1575 {
1578 }
1580 {
1583 }
1584 else
1585 {
1588 }
1590 /* stupid Microsloth API does not work for zero-length input */
1593 else
1594 {
1601 }
1606 else
1607 {
1614 }
1618 #ifdef HAVE_LOCALE_T
1621 else
1622 #endif
1625 * headers */
1629 /* Break tie if necessary. */
1632 {
1636 }
1644 }
1649 else
1653 else
1662 {
1664 {
1665 #ifdef USE_ICU
1666 #ifdef HAVE_UCOL_STRCOLLUTF8
1668 {
1669 UErrorCode status;
1679 }
1680 else
1681 #endif
1682 {
1684 ulen2;
1697 }
1699 /* shouldn't happen */
1702 }
1703 else
1704 {
1705 #ifdef HAVE_LOCALE_T
1707 #else
1708 /* shouldn't happen */
1710 #endif
1711 }
1712 }
1713 else
1716 /* Break tie if necessary. */
1725 }
1728 }
1730 /* text_cmp()
1731 * Internal comparison function for text strings.
1732 * Returns -1, 0 or 1
1733 */
1734 static int
1736 {
1740 len2;
1749 }
1751 /*
1752 * Comparison functions for text strings.
1753 *
1754 * Note: btree indexes need these routines not to leak memory; therefore,
1755 * be careful to free working copies of toasted datums. Most places don't
1756 * need to be so careful.
1757 */
1759 Datum
1761 {
1771 else
1775 {
1778 Size len1,
1779 len2;
1781 /*
1782 * Since we only care about equality or not-equality, we can avoid all
1783 * the expense of strcoll() here, and just do bitwise comparison. In
1784 * fact, we don't even have to do a bitwise comparison if we can show
1785 * the lengths of the strings are unequal; which might save us from
1786 * having to detoast one or both values.
1787 */
1792 else
1793 {
1802 }
1803 }
1804 else
1805 {
1813 }
1816 }
1818 Datum
1820 {
1830 else
1834 {
1837 Size len1,
1838 len2;
1840 /* See comment in texteq() */
1845 else
1846 {
1855 }
1856 }
1857 else
1858 {
1866 }
1869 }
1871 Datum
1873 {
1884 }
1886 Datum
1888 {
1899 }
1901 Datum
1903 {
1914 }
1916 Datum
1918 {
1929 }
1931 Datum
1933 {
1939 Size len1,
1940 len2;
1956 else
1957 {
1966 }
1969 }
1971 Datum
1973 {
1976 int32 result;
1984 }
1986 Datum
1988 {
1991 MemoryContext oldcontext;
1995 /* Use generic string SortSupport */
2001 }
2003 /*
2004 * Generic sortsupport interface for character type's operator classes.
2005 * Includes locale support, and support for BpChar semantics (i.e. removing
2006 * trailing spaces before comparison).
2007 *
2008 * Relies on the assumption that text, VarChar, BpChar, and bytea all have the
2009 * same representation. Callers that always use the C collation (e.g.
2010 * non-collatable type callers like bytea) may have NUL bytes in their strings;
2011 * this will not work with any other collation, though.
2012 */
2013 void
2015 {
2023 /*
2024 * If possible, set ssup->comparator to a function which can be used to
2025 * directly compare two datums. If we can do this, we'll avoid the
2026 * overhead of a trip through the fmgr layer for every comparison, which
2027 * can be substantial.
2028 *
2029 * Most typically, we'll set the comparator to varlenafastcmp_locale,
2030 * which uses strcoll() to perform comparisons. We use that for the
2031 * BpChar case too, but type NAME uses namefastcmp_locale. However, if
2032 * LC_COLLATE = C, we can make things quite a bit faster with
2033 * varstrfastcmp_c, bpcharfastcmp_c, or namefastcmp_c, all of which use
2034 * memcmp() rather than strcoll().
2035 */
2037 {
2041 {
2043 /* Not supporting abbreviation with type NAME, for now */
2045 }
2046 else
2050 }
2051 else
2052 {
2053 /*
2054 * We need a collation-sensitive comparison. To make things faster,
2055 * we'll figure out the collation based on the locale id and cache the
2056 * result.
2057 */
2060 /*
2061 * There is a further exception on Windows. When the database
2062 * encoding is UTF-8 and we are not using the C collation, complex
2063 * hacks are required. We don't currently have a comparator that
2064 * handles that case, so we fall back on the slow method of having the
2065 * sort code invoke bttextcmp() (in the case of text) via the fmgr
2066 * trampoline. ICU locales work just the same on Windows, however.
2067 */
2068 #ifdef WIN32
2072 #endif
2074 /*
2075 * We use varlenafastcmp_locale except for type NAME.
2076 */
2078 {
2080 /* Not supporting abbreviation with type NAME, for now */
2082 }
2083 else
2085 }
2087 /*
2088 * Unfortunately, it seems that abbreviation for non-C collations is
2089 * broken on many common platforms; testing of multiple versions of glibc
2090 * reveals that, for many locales, strcoll() and strxfrm() do not return
2091 * consistent results, which is fatal to this optimization. While no
2092 * other libc other than Cygwin has so far been shown to have a problem,
2093 * we take the conservative course of action for right now and disable
2094 * this categorically. (Users who are certain this isn't a problem on
2095 * their system can define TRUST_STRXFRM.)
2096 *
2097 * Even apart from the risk of broken locales, it's possible that there
2098 * are platforms where the use of abbreviated keys should be disabled at
2099 * compile time. Having only 4 byte datums could make worst-case
2100 * performance drastically more likely, for example. Moreover, macOS's
2101 * strxfrm() implementation is known to not effectively concentrate a
2102 * significant amount of entropy from the original string in earlier
2103 * transformed blobs. It's possible that other supported platforms are
2104 * similarly encumbered. So, if we ever get past disabling this
2105 * categorically, we may still want or need to disable it for particular
2106 * platforms.
2107 */
2108 #ifndef TRUST_STRXFRM
2111 #endif
2113 /*
2114 * If we're using abbreviated keys, or if we're using a locale-aware
2115 * comparison, we need to initialize a VarStringSortSupport object. Both
2116 * cases will make use of the temporary buffers we initialize here for
2117 * scratch space (and to detect requirement for BpChar semantics from
2118 * caller), and the abbreviation case requires additional state.
2119 */
2121 {
2127 /* Start with invalid values */
2130 /* Initialize */
2134 /*
2135 * To avoid somehow confusing a strxfrm() blob and an original string,
2136 * constantly keep track of the variety of data that buf1 and buf2
2137 * currently contain.
2138 *
2139 * Comparisons may be interleaved with conversion calls. Frequently,
2140 * conversions and comparisons are batched into two distinct phases,
2141 * but the correctness of caching cannot hinge upon this. For
2142 * comparison caching, buffer state is only trusted if cache_blob is
2143 * found set to false, whereas strxfrm() caching only trusts the state
2144 * when cache_blob is found set to true.
2145 *
2146 * Arbitrarily initialize cache_blob to true.
2147 */
2153 /*
2154 * If possible, plan to use the abbreviated keys optimization. The
2155 * core code may switch back to authoritative comparator should
2156 * abbreviation be aborted.
2157 */
2159 {
2167 }
2168 }
2169 }
2171 /*
2172 * sortsupport comparison func (for C locale case)
2173 */
2174 static int
2176 {
2182 len2,
2183 result;
2195 /* We can't afford to leak memory here. */
2202 }
2204 /*
2205 * sortsupport comparison func (for BpChar C locale case)
2206 *
2207 * BpChar outsources its sortsupport to this module. Specialization for the
2208 * varstr_sortsupport BpChar case, modeled on
2209 * internal_bpchar_pattern_compare().
2210 */
2211 static int
2213 {
2219 len2,
2220 result;
2232 /* We can't afford to leak memory here. */
2239 }
2241 /*
2242 * sortsupport comparison func (for NAME C locale case)
2243 */
2244 static int
2246 {
2251 }
2253 /*
2254 * sortsupport comparison func (for locale case with all varlena types)
2255 */
2256 static int
2258 {
2264 len2,
2265 result;
2275 /* We can't afford to leak memory here. */
2282 }
2284 /*
2285 * sortsupport comparison func (for locale case with NAME type)
2286 */
2287 static int
2289 {
2295 ssup);
2296 }
2298 /*
2299 * sortsupport comparison func for locale cases
2300 */
2301 static int
2303 {
2308 /* Fast pre-check for equality, as discussed in varstr_cmp() */
2310 {
2311 /*
2312 * No change in buf1 or buf2 contents, so avoid changing last_len1 or
2313 * last_len2. Existing contents of buffers might still be used by
2314 * next call.
2315 *
2316 * It's fine to allow the comparison of BpChar padding bytes here,
2317 * even though that implies that the memcmp() will usually be
2318 * performed for BpChar callers (though multibyte characters could
2319 * still prevent that from occurring). The memcmp() is still very
2320 * cheap, and BpChar's funny semantics have us remove trailing spaces
2321 * (not limited to padding), so we need make no distinction between
2322 * padding space characters and "real" space characters.
2323 */
2325 }
2328 {
2329 /* Get true number of bytes, ignoring trailing spaces */
2332 }
2335 {
2338 }
2340 {
2343 }
2345 /*
2346 * We're likely to be asked to compare the same strings repeatedly, and
2347 * memcmp() is so much cheaper than strcoll() that it pays to try to cache
2348 * comparisons, even though in general there is no reason to think that
2349 * that will work out (every string datum may be unique). Caching does
2350 * not slow things down measurably when it doesn't work out, and can speed
2351 * things up by rather a lot when it does. In part, this is because the
2352 * memcmp() compares data from cachelines that are needed in L1 cache even
2353 * when the last comparison's result cannot be reused.
2354 */
2357 {
2362 }
2364 /*
2365 * If we're comparing the same two strings as last time, we can return the
2366 * same answer without calling strcoll() again. This is more likely than
2367 * it seems (at least with moderate to low cardinality sets), because
2368 * quicksort compares the same pivot against many values.
2369 */
2371 {
2375 }
2377 {
2378 /* Use result cached following last actual strcoll() call */
2380 }
2383 {
2385 {
2386 #ifdef USE_ICU
2387 #ifdef HAVE_UCOL_STRCOLLUTF8
2389 {
2390 UErrorCode status;
2400 }
2401 else
2402 #endif
2403 {
2405 ulen2;
2418 }
2420 /* shouldn't happen */
2423 }
2424 else
2425 {
2426 #ifdef HAVE_LOCALE_T
2428 #else
2429 /* shouldn't happen */
2431 #endif
2432 }
2433 }
2434 else
2437 /* Break tie if necessary. */
2442 /* Cache result, perhaps saving an expensive strcoll() call next time */
2446 }
2448 /*
2449 * Conversion routine for sortsupport. Converts original to abbreviated key
2450 * representation. Our encoding strategy is simple -- pack the first 8 bytes
2451 * of a strxfrm() blob into a Datum (on little-endian machines, the 8 bytes are
2452 * stored in reverse order), and treat it as an unsigned integer. When the "C"
2453 * locale is used, or in case of bytea, just memcpy() from original instead.
2454 */
2455 static Datum
2457 {
2462 /* working state */
2463 Datum res;
2466 uint32 hash;
2469 /* memset(), so any non-overwritten bytes are NUL */
2473 /* Get number of bytes, ignoring trailing spaces */
2477 /*
2478 * If we're using the C collation, use memcpy(), rather than strxfrm(), to
2479 * abbreviate keys. The full comparator for the C locale is always
2480 * memcmp(). It would be incorrect to allow bytea callers (callers that
2481 * always force the C collation -- bytea isn't a collatable type, but this
2482 * approach is convenient) to use strxfrm(). This is because bytea
2483 * strings may contain NUL bytes. Besides, this should be faster, too.
2484 *
2485 * More generally, it's okay that bytea callers can have NUL bytes in
2486 * strings because abbreviated cmp need not make a distinction between
2487 * terminating NUL bytes, and NUL bytes representing actual NULs in the
2488 * authoritative representation. Hopefully a comparison at or past one
2489 * abbreviated key's terminating NUL byte will resolve the comparison
2490 * without consulting the authoritative representation; specifically, some
2491 * later non-NUL byte in the longer string can resolve the comparison
2492 * against a subsequent terminating NUL in the shorter string. There will
2493 * usually be what is effectively a "length-wise" resolution there and
2494 * then.
2495 *
2496 * If that doesn't work out -- if all bytes in the longer string
2497 * positioned at or past the offset of the smaller string's (first)
2498 * terminating NUL are actually representative of NUL bytes in the
2499 * authoritative binary string (perhaps with some *terminating* NUL bytes
2500 * towards the end of the longer string iff it happens to still be small)
2501 * -- then an authoritative tie-breaker will happen, and do the right
2502 * thing: explicitly consider string length.
2503 */
2506 else
2507 {
2508 Size bsize;
2509 #ifdef USE_ICU
2512 #endif
2514 /*
2515 * We're not using the C collation, so fall back on strxfrm or ICU
2516 * analogs.
2517 */
2519 /* By convention, we use buffer 1 to store and NUL-terminate */
2521 {
2524 }
2526 /* Might be able to reuse strxfrm() blob from last call */
2529 {
2531 /* No change affecting cardinality, so no hashing required */
2533 }
2537 /*
2538 * Just like strcoll(), strxfrm() expects a NUL-terminated string. Not
2539 * necessary for ICU, but doesn't hurt.
2540 */
2544 #ifdef USE_ICU
2545 /* When using ICU and not UTF8, convert string to UChar. */
2549 #endif
2551 /*
2552 * Loop: Call strxfrm() or ucol_getSortKey(), possibly enlarge buffer,
2553 * and try again. Both of these functions have the result buffer
2554 * content undefined if the result did not fit, so we need to retry
2555 * until everything fits, even though we only need the first few bytes
2556 * in the end. When using ucol_nextSortKeyPart(), however, we only
2557 * ask for as many bytes as we actually need.
2558 */
2560 {
2561 #ifdef USE_ICU
2563 {
2564 /*
2565 * When using UTF8, use the iteration interface so we only
2566 * need to produce as many bytes as we actually need.
2567 */
2569 {
2570 UCharIterator iter;
2572 UErrorCode status;
2579 state,
2587 }
2588 else
2592 }
2593 else
2594 #endif
2595 #ifdef HAVE_LOCALE_T
2599 else
2600 #endif
2607 /*
2608 * Grow buffer and retry.
2609 */
2613 }
2615 /*
2616 * Every Datum byte is always compared. This is safe because the
2617 * strxfrm() blob is itself NUL terminated, leaving no danger of
2618 * misinterpreting any NUL bytes not intended to be interpreted as
2619 * logically representing termination.
2620 *
2621 * (Actually, even if there were NUL bytes in the blob it would be
2622 * okay. See remarks on bytea case above.)
2623 */
2626 #ifdef USE_ICU
2629 #endif
2630 }
2632 /*
2633 * Maintain approximate cardinality of both abbreviated keys and original,
2634 * authoritative keys using HyperLogLog. Used as cheap insurance against
2635 * the worst case, where we do many string transformations for no saving
2636 * in full strcoll()-based comparisons. These statistics are used by
2637 * varstr_abbrev_abort().
2638 *
2639 * First, Hash key proper, or a significant fraction of it. Mix in length
2640 * in order to compensate for cases where differences are past
2641 * PG_CACHE_LINE_SIZE bytes, so as to limit the overhead of hashing.
2642 */
2651 /* Hash abbreviated key */
2652 #if SIZEOF_DATUM == 8
2653 {
2654 uint32 lohalf,
2655 hihalf;
2660 }
2663 #endif
2667 /* Cache result, perhaps saving an expensive strxfrm() call next time */
2669 done:
2671 /*
2672 * Byteswap on little-endian machines.
2673 *
2674 * This is needed so that ssup_datum_unsigned_cmp() (an unsigned integer
2675 * 3-way comparator) works correctly on all platforms. If we didn't do
2676 * this, the comparator would have to call memcmp() with a pair of
2677 * pointers to the first byte of each abbreviated key, which is slower.
2678 */
2681 /* Don't leak memory here */
2686 }
2688 /*
2689 * Callback for estimating effectiveness of abbreviated key optimization, using
2690 * heuristic rules. Returns value indicating if the abbreviation optimization
2691 * should be aborted, based on its projected effectiveness.
2692 */
2693 static bool
2695 {
2698 key_distinct;
2702 /* Have a little patience */
2709 /*
2710 * Clamp cardinality estimates to at least one distinct value. While
2711 * NULLs are generally disregarded, if only NULL values were seen so far,
2712 * that might misrepresent costs if we failed to clamp.
2713 */
2720 /*
2721 * In the worst case all abbreviated keys are identical, while at the same
2722 * time there are differences within full key strings not captured in
2723 * abbreviations.
2724 */
2725 #ifdef TRACE_SORT
2727 {
2734 }
2735 #endif
2737 /*
2738 * If the number of distinct abbreviated keys approximately matches the
2739 * number of distinct authoritative original keys, that's reason enough to
2740 * proceed. We can win even with a very low cardinality set if most
2741 * tie-breakers only memcmp(). This is by far the most important
2742 * consideration.
2743 *
2744 * While comparisons that are resolved at the abbreviated key level are
2745 * considerably cheaper than tie-breakers resolved with memcmp(), both of
2746 * those two outcomes are so much cheaper than a full strcoll() once
2747 * sorting is underway that it doesn't seem worth it to weigh abbreviated
2748 * cardinality against the overall size of the set in order to more
2749 * accurately model costs. Assume that an abbreviated comparison, and an
2750 * abbreviated comparison with a cheap memcmp()-based authoritative
2751 * resolution are equivalent.
2752 */
2754 {
2755 /*
2756 * When we have exceeded 10,000 tuples, decay required cardinality
2757 * aggressively for next call.
2758 *
2759 * This is useful because the number of comparisons required on
2760 * average increases at a linearithmic rate, and at roughly 10,000
2761 * tuples that factor will start to dominate over the linear costs of
2762 * string transformation (this is a conservative estimate). The decay
2763 * rate is chosen to be a little less aggressive than halving -- which
2764 * (since we're called at points at which memtupcount has doubled)
2765 * would never see the cost model actually abort past the first call
2766 * following a decay. This decay rate is mostly a precaution against
2767 * a sudden, violent swing in how well abbreviated cardinality tracks
2768 * full key cardinality. The decay also serves to prevent a marginal
2769 * case from being aborted too late, when too much has already been
2770 * invested in string transformation.
2771 *
2772 * It's possible for sets of several million distinct strings with
2773 * mere tens of thousands of distinct abbreviated keys to still
2774 * benefit very significantly. This will generally occur provided
2775 * each abbreviated key is a proxy for a roughly uniform number of the
2776 * set's full keys. If it isn't so, we hope to catch that early and
2777 * abort. If it isn't caught early, by the time the problem is
2778 * apparent it's probably not worth aborting.
2779 */
2784 }
2786 /*
2787 * Abort abbreviation strategy.
2788 *
2789 * The worst case, where all abbreviated keys are identical while all
2790 * original strings differ will typically only see a regression of about
2791 * 10% in execution time for small to medium sized lists of strings.
2792 * Whereas on modern CPUs where cache stalls are the dominant cost, we can
2793 * often expect very large improvements, particularly with sets of strings
2794 * of moderately high to high abbreviated cardinality. There is little to
2795 * lose but much to gain, which our strategy reflects.
2796 */
2797 #ifdef TRACE_SORT
2802 #endif
2805 }
2807 /*
2808 * Generic equalimage support function for character type's operator classes.
2809 * Disables the use of deduplication with nondeterministic collations.
2810 */
2811 Datum
2813 {
2814 /* Oid opcintype = PG_GETARG_OID(0); */
2823 else
2825 }
2827 Datum
2829 {
2837 }
2839 Datum
2841 {
2849 }
2852 /*
2853 * Cross-type comparison functions for types text and name.
2854 */
2856 Datum
2858 {
2871 else
2879 }
2881 Datum
2883 {
2896 else
2904 }
2906 Datum
2908 {
2921 else
2929 }
2931 Datum
2933 {
2946 else
2954 }
2956 Datum
2958 {
2961 int32 result;
2970 }
2972 Datum
2974 {
2977 int32 result;
2986 }
2988 #define CmpCall(cmpfunc) \
2989 DatumGetInt32(DirectFunctionCall2Coll(cmpfunc, \
2990 PG_GET_COLLATION(), \
2991 PG_GETARG_DATUM(0), \
2992 PG_GETARG_DATUM(1)))
2994 Datum
2996 {
2998 }
3000 Datum
3002 {
3004 }
3006 Datum
3008 {
3010 }
3012 Datum
3014 {
3016 }
3018 Datum
3020 {
3022 }
3024 Datum
3026 {
3028 }
3030 Datum
3032 {
3034 }
3036 Datum
3038 {
3040 }
3042 #undef CmpCall
3045 /*
3046 * The following operators support character-by-character comparison
3047 * of text datums, to allow building indexes suitable for LIKE clauses.
3048 * Note that the regular texteq/textne comparison operators, and regular
3049 * support functions 1 and 2 with "C" collation are assumed to be
3050 * compatible with these!
3051 */
3053 static int
3055 {
3058 len2;
3070 else
3072 }
3075 Datum
3077 {
3088 }
3091 Datum
3093 {
3104 }
3107 Datum
3109 {
3120 }
3123 Datum
3125 {
3136 }
3139 Datum
3141 {
3152 }
3155 Datum
3157 {
3159 MemoryContext oldcontext;
3163 /* Use generic string SortSupport, forcing "C" collation */
3169 }
3172 /*-------------------------------------------------------------
3173 * byteaoctetlen
3174 *
3175 * get the number of bytes contained in an instance of type 'bytea'
3176 *-------------------------------------------------------------
3177 */
3178 Datum
3180 {
3183 /* We need not detoast the input at all */
3185 }
3187 /*
3188 * byteacat -
3189 * takes two bytea* and returns a bytea* that is the concatenation of
3190 * the two.
3191 *
3192 * Cloned from textcat and modified as required.
3193 */
3194 Datum
3196 {
3201 }
3203 /*
3204 * bytea_catenate
3205 * Guts of byteacat(), broken out so it can be used by other functions
3206 *
3207 * Arguments can be in short-header form, but not compressed or out-of-line
3208 */
3211 {
3214 len2,
3215 len;
3221 /* paranoia ... probably should throw error instead? */
3230 /* Set size of result string... */
3233 /* Fill data field of result string... */
3241 }
3243 #define PG_STR_GET_BYTEA(str_) \
3244 DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))
3246 /*
3247 * bytea_substr()
3248 * Return a substring starting at the specified position.
3249 * Cloned from text_substr and modified as required.
3250 *
3251 * Input:
3252 * - string
3253 * - starting position (is one-based)
3254 * - string length (optional)
3255 *
3256 * If the starting position is zero or less, then return from the start of the string
3257 * adjusting the length to be consistent with the "negative start" per SQL.
3258 * If the length is less than zero, an ERROR is thrown. If no third argument
3259 * (length) is provided, the length to the end of the string is assumed.
3260 */
3261 Datum
3263 {
3268 }
3270 /*
3271 * bytea_substr_no_len -
3272 * Wrapper to avoid opr_sanity failure due to
3273 * one function accepting a different number of args.
3274 */
3275 Datum
3277 {
3282 }
3289 {
3294 /*
3295 * The logic here should generally match text_substring().
3296 */
3300 {
3301 /*
3302 * Not passed a length - DatumGetByteaPSlice() grabs everything to the
3303 * end of the string if we pass it a negative value for length.
3304 */
3306 }
3308 {
3309 /* SQL99 says to throw an error for E < S, i.e., negative length */
3314 }
3316 {
3317 /*
3318 * L could be large enough for S + L to overflow, in which case the
3319 * substring must run to end of string.
3320 */
3322 }
3323 else
3324 {
3325 /*
3326 * A zero or negative value for the end position can happen if the
3327 * start was negative or one. SQL99 says to return a zero-length
3328 * string.
3329 */
3334 }
3336 /*
3337 * If the start position is past the end of the string, SQL99 says to
3338 * return a zero-length string -- DatumGetByteaPSlice() will do that for
3339 * us. We need only convert S1 to zero-based starting position.
3340 */
3342 }
3344 /*
3345 * byteaoverlay
3346 * Replace specified substring of first string with second
3347 *
3348 * The SQL standard defines OVERLAY() in terms of substring and concatenation.
3349 * This code is a direct implementation of what the standard says.
3350 */
3351 Datum
3353 {
3360 }
3362 Datum
3364 {
3372 }
3376 {
3382 /*
3383 * Check for possible integer-overflow cases. For negative sp, throw a
3384 * "substring length" error because that's what should be expected
3385 * according to the spec's definition of OVERLAY().
3386 */
3402 }
3404 /*
3405 * bit_count
3406 */
3407 Datum
3409 {
3413 }
3415 /*
3416 * byteapos -
3417 * Return the position of the specified substring.
3418 * Implements the SQL POSITION() function.
3419 * Cloned from textpos and modified as required.
3420 */
3421 Datum
3423 {
3428 p;
3430 len2;
3446 {
3448 {
3451 };
3452 p1++;
3453 };
3456 }
3458 /*-------------------------------------------------------------
3459 * byteaGetByte
3460 *
3461 * this routine treats "bytea" as an array of bytes.
3462 * It returns the Nth byte (a number between 0 and 255).
3463 *-------------------------------------------------------------
3464 */
3465 Datum
3467 {
3484 }
3486 /*-------------------------------------------------------------
3487 * byteaGetBit
3488 *
3489 * This routine treats a "bytea" type like an array of bits.
3490 * It returns the value of the Nth bit (0 or 1).
3491 *
3492 *-------------------------------------------------------------
3493 */
3494 Datum
3496 {
3500 bitNo;
3512 /* n/8 is now known < len, so safe to cast to int */
3520 else
3522 }
3524 /*-------------------------------------------------------------
3525 * byteaSetByte
3526 *
3527 * Given an instance of type 'bytea' creates a new one with
3528 * the Nth byte set to the given value.
3529 *
3530 *-------------------------------------------------------------
3531 */
3532 Datum
3534 {
3548 /*
3549 * Now set the byte.
3550 */
3554 }
3556 /*-------------------------------------------------------------
3557 * byteaSetBit
3558 *
3559 * Given an instance of type 'bytea' creates a new one with
3560 * the Nth bit set to the given value.
3561 *
3562 *-------------------------------------------------------------
3563 */
3564 Datum
3566 {
3572 newByte;
3574 bitNo;
3584 /* n/8 is now known < len, so safe to cast to int */
3588 /*
3589 * sanity check!
3590 */
3596 /*
3597 * Update the byte.
3598 */
3603 else
3609 }
3612 /* text_name()
3613 * Converts a text type to a Name type.
3614 */
3615 Datum
3617 {
3619 Name result;
3624 /* Truncate oversize input */
3628 /* We use palloc0 here to ensure result is zero-padded */
3633 }
3635 /* name_text()
3636 * Converts a Name type to a text type.
3637 */
3638 Datum
3640 {
3644 }
3647 /*
3648 * textToQualifiedNameList - convert a text object to list of names
3649 *
3650 * This implements the input parsing needed by nextval() and other
3651 * functions that take a text parameter representing a qualified name.
3652 * We split the name at dots, downcase if not double-quoted, and
3653 * truncate names if they're too long.
3654 */
3655 List *
3657 {
3663 /* Convert to C string (handles possible detoasting). */
3664 /* Note we rely on being able to modify rawname below. */
3678 {
3682 }
3688 }
3690 /*
3691 * SplitIdentifierString --- parse a string containing identifiers
3692 *
3693 * This is the guts of textToQualifiedNameList, and is exported for use in
3694 * other situations such as parsing GUC variables. In the GUC case, it's
3695 * important to avoid memory leaks, so the API is designed to minimize the
3696 * amount of stuff that needs to be allocated and freed.
3697 *
3698 * Inputs:
3699 * rawstring: the input string; must be overwritable! On return, it's
3700 * been modified to contain the separated identifiers.
3701 * separator: the separator punctuation expected between identifiers
3702 * (typically '.' or ','). Whitespace may also appear around
3703 * identifiers.
3704 * Outputs:
3705 * namelist: filled with a palloc'd list of pointers to identifiers within
3706 * rawstring. Caller should list_free() this even on error return.
3707 *
3708 * Returns true if okay, false if there is a syntax error in the string.
3709 *
3710 * Note that an empty string is considered okay here, though not in
3711 * textToQualifiedNameList.
3712 */
3713 bool
3716 {
3728 /* At the top of the loop, we are at start of a new identifier. */
3729 do
3730 {
3735 {
3736 /* Quoted name --- collapse quote-quote pairs, no downcasing */
3739 {
3745 /* Collapse adjacent quotes into one quote, and look again */
3748 }
3749 /* endp now points at the terminating quote */
3751 }
3752 else
3753 {
3754 /* Unquoted name --- extends to separator or whitespace */
3761 nextp++;
3766 /*
3767 * Downcase the identifier, using same code as main lexer does.
3768 *
3769 * XXX because we want to overwrite the input in-place, we cannot
3770 * support a downcasing transformation that increases the string
3771 * length. This is not a problem given the current implementation
3772 * of downcase_truncate_identifier, but we'll probably have to do
3773 * something about this someday.
3774 */
3780 }
3786 {
3787 nextp++;
3790 /* we expect another name, so done remains false */
3791 }
3794 else
3797 /* Now safe to overwrite separator with a null */
3800 /* Truncate name if it's overlength */
3803 /*
3804 * Finished isolating current name --- add it to list
3805 */
3808 /* Loop back if we didn't reach end of string */
3812 }
3815 /*
3816 * SplitDirectoriesString --- parse a string containing file/directory names
3817 *
3818 * This works fine on file names too; the function name is historical.
3819 *
3820 * This is similar to SplitIdentifierString, except that the parsing
3821 * rules are meant to handle pathnames instead of identifiers: there is
3822 * no downcasing, embedded spaces are allowed, the max length is MAXPGPATH-1,
3823 * and we apply canonicalize_path() to each extracted string. Because of the
3824 * last, the returned strings are separately palloc'd rather than being
3825 * pointers into rawstring --- but we still scribble on rawstring.
3826 *
3827 * Inputs:
3828 * rawstring: the input string; must be modifiable!
3829 * separator: the separator punctuation expected between directories
3830 * (typically ',' or ';'). Whitespace may also appear around
3831 * directories.
3832 * Outputs:
3833 * namelist: filled with a palloc'd list of directory names.
3834 * Caller should list_free_deep() this even on error return.
3835 *
3836 * Returns true if okay, false if there is a syntax error in the string.
3837 *
3838 * Note that an empty string is considered okay here.
3839 */
3840 bool
3843 {
3855 /* At the top of the loop, we are at start of a new directory. */
3856 do
3857 {
3862 {
3863 /* Quoted name --- collapse quote-quote pairs */
3866 {
3872 /* Collapse adjacent quotes into one quote, and look again */
3875 }
3876 /* endp now points at the terminating quote */
3878 }
3879 else
3880 {
3881 /* Unquoted name --- extends to separator or end of string */
3884 {
3885 /* trailing whitespace should not be included in name */
3888 nextp++;
3889 }
3892 }
3898 {
3899 nextp++;
3902 /* we expect another name, so done remains false */
3903 }
3906 else
3909 /* Now safe to overwrite separator with a null */
3912 /* Truncate path if it's overlength */
3916 /*
3917 * Finished isolating current name --- add it to list
3918 */
3923 /* Loop back if we didn't reach end of string */
3927 }
3930 /*
3931 * SplitGUCList --- parse a string containing identifiers or file names
3932 *
3933 * This is used to split the value of a GUC_LIST_QUOTE GUC variable, without
3934 * presuming whether the elements will be taken as identifiers or file names.
3935 * We assume the input has already been through flatten_set_variable_args(),
3936 * so that we need never downcase (if appropriate, that was done already).
3937 * Nor do we ever truncate, since we don't know the correct max length.
3938 * We disallow embedded whitespace for simplicity (it shouldn't matter,
3939 * because any embedded whitespace should have led to double-quoting).
3940 * Otherwise the API is identical to SplitIdentifierString.
3941 *
3942 * XXX it's annoying to have so many copies of this string-splitting logic.
3943 * However, it's not clear that having one function with a bunch of option
3944 * flags would be much better.
3945 *
3946 * XXX there is a version of this function in src/bin/pg_dump/dumputils.c.
3947 * Be sure to update that if you have to change this.
3948 *
3949 * Inputs:
3950 * rawstring: the input string; must be overwritable! On return, it's
3951 * been modified to contain the separated identifiers.
3952 * separator: the separator punctuation expected between identifiers
3953 * (typically '.' or ','). Whitespace may also appear around
3954 * identifiers.
3955 * Outputs:
3956 * namelist: filled with a palloc'd list of pointers to identifiers within
3957 * rawstring. Caller should list_free() this even on error return.
3958 *
3959 * Returns true if okay, false if there is a syntax error in the string.
3960 */
3961 bool
3964 {
3976 /* At the top of the loop, we are at start of a new identifier. */
3977 do
3978 {
3983 {
3984 /* Quoted name --- collapse quote-quote pairs */
3987 {
3993 /* Collapse adjacent quotes into one quote, and look again */
3996 }
3997 /* endp now points at the terminating quote */
3999 }
4000 else
4001 {
4002 /* Unquoted name --- extends to separator or whitespace */
4006 nextp++;
4010 }
4016 {
4017 nextp++;
4020 /* we expect another name, so done remains false */
4021 }
4024 else
4027 /* Now safe to overwrite separator with a null */
4030 /*
4031 * Finished isolating current name --- add it to list
4032 */
4035 /* Loop back if we didn't reach end of string */
4039 }
4042 /*****************************************************************************
4043 * Comparison Functions used for bytea
4044 *
4045 * Note: btree indexes need these routines not to leak memory; therefore,
4046 * be careful to free working copies of toasted datums. Most places don't
4047 * need to be so careful.
4048 *****************************************************************************/
4050 Datum
4052 {
4056 Size len1,
4057 len2;
4059 /*
4060 * We can use a fast path for unequal lengths, which might save us from
4061 * having to detoast one or both values.
4062 */
4067 else
4068 {
4077 }
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 len2;
4132 }
4134 Datum
4136 {
4140 len2;
4152 }
4154 Datum
4156 {
4160 len2;
4172 }
4174 Datum
4176 {
4180 len2;
4192 }
4194 Datum
4196 {
4200 len2;
4214 }
4216 Datum
4218 {
4220 MemoryContext oldcontext;
4224 /* Use generic string SortSupport, forcing "C" collation */
4230 }
4232 /*
4233 * appendStringInfoText
4234 *
4235 * Append a text to str.
4236 * Like appendStringInfoString(str, text_to_cstring(t)) but faster.
4237 */
4238 static void
4240 {
4242 }
4244 /*
4245 * replace_text
4246 * replace all occurrences of 'old_sub_str' in 'orig_str'
4247 * with 'new_sub_str' to form 'new_str'
4248 *
4249 * returns 'orig_str' if 'old_sub_str' == '' or 'orig_str' == ''
4250 * otherwise returns 'new_str'
4251 */
4252 Datum
4254 {
4260 TextPositionState state;
4265 StringInfoData str;
4271 /* Return unmodified source string if empty source or pattern */
4273 {
4275 }
4281 /* When the from_sub_text is not found, there is nothing to do. */
4283 {
4286 }
4292 do
4293 {
4296 /* copy the data skipped over by last text_position_next() */
4307 }
4310 /* copy trailing data */
4320 }
4322 /*
4323 * check_replace_text_has_escape
4324 *
4325 * Returns 0 if text contains no backslashes that need processing.
4326 * Returns 1 if text contains backslashes, but not regexp submatch specifiers.
4327 * Returns 2 if text contains regexp submatch specifiers (\1 .. \9).
4328 */
4329 static int
4331 {
4337 {
4338 /* Find next escape char, if any. */
4342 p++;
4343 /* Note: a backslash at the end doesn't require extra processing. */
4345 {
4349 p++;
4350 }
4351 }
4353 }
4355 /*
4356 * appendStringInfoRegexpSubstr
4357 *
4358 * Append replace_text to str, substituting regexp back references for
4359 * \n escapes. start_ptr is the start of the match in the source string,
4360 * at logical character position data_pos.
4361 */
4362 static void
4366 {
4371 {
4376 /* Find next escape char, if any. */
4381 /* Copy the text we just scanned over, if any. */
4385 /* Done if at end of string, else advance over escape char. */
4388 p++;
4391 {
4392 /* Escape at very end of input. Treat same as unexpected char */
4395 }
4398 {
4399 /* Use the back reference of regexp. */
4404 p++;
4405 }
4407 {
4408 /* Use the entire matched string. */
4411 p++;
4412 }
4414 {
4415 /* \\ means transfer one \ to output. */
4417 p++;
4419 }
4420 else
4421 {
4422 /*
4423 * If escape char is not followed by any expected char, just treat
4424 * it as ordinary data to copy. (XXX would it be better to throw
4425 * an error?)
4426 */
4429 }
4432 {
4433 /*
4434 * Copy the text that is back reference of regexp. Note so and eo
4435 * are counted in characters not bytes.
4436 */
4445 }
4446 }
4447 }
4449 /*
4450 * replace_text_regexp
4451 *
4452 * replace substring(s) in src_text that match pattern with replace_text.
4453 * The replace_text can contain backslash markers to substitute
4454 * (parts of) the matched text.
4455 *
4456 * cflags: regexp compile flags.
4457 * collation: collation to use.
4458 * search_start: the character (not byte) offset in src_text at which to
4459 * begin searching.
4460 * n: if 0, replace all matches; if > 0, replace only the N'th match.
4461 */
4462 text *
4467 {
4472 StringInfoData buf;
4483 /* Convert data string to wide characters. */
4487 /* Check whether replace_text has escapes, especially regexp submatches. */
4490 /* If no regexp submatches, we can use REG_NOSUB. */
4492 {
4494 /* Also tell pg_regexec we only want the whole-match location. */
4496 }
4498 /* Prepare the regexp. */
4501 /* start_ptr points to the data_pos'th character of src_text */
4506 {
4512 data,
4513 data_len,
4514 search_start,
4516 nmatch,
4517 pmatch,
4524 {
4532 }
4534 /*
4535 * Count matches, and decide whether to replace this match.
4536 */
4537 nmatches++;
4539 {
4540 /*
4541 * No, so advance search_start, but not start_ptr/data_pos. (Thus,
4542 * we treat the matched text as if it weren't matched, and copy it
4543 * to the output later.)
4544 */
4547 search_start++;
4549 }
4551 /*
4552 * Copy the text to the left of the match position. Note we are given
4553 * character not byte indexes.
4554 */
4556 {
4563 /*
4564 * Advance start_ptr over that text, to avoid multiple rescans of
4565 * it if the replace_text contains multiple back-references.
4566 */
4569 }
4571 /*
4572 * Copy the replace_text, processing escapes if any are present.
4573 */
4577 else
4580 /* Advance start_ptr and data_pos over the matched text. */
4585 /*
4586 * If we only want to replace one occurrence, we're done.
4587 */
4591 /*
4592 * Advance search position. Normally we start the next search at the
4593 * end of the previous match; but if the match was of zero length, we
4594 * have to advance by one character, or we'd just find the same match
4595 * again.
4596 */
4599 search_start++;
4600 }
4602 /*
4603 * Copy the text to the right of the last match.
4604 */
4606 {
4611 }
4618 }
4620 /*
4621 * split_part
4622 * parse input string based on provided field separator
4623 * return N'th item (1 based, negative counts from end)
4624 */
4625 Datum
4627 {
4633 TextPositionState state;
4639 /* field number is 1 based */
4648 /* return empty string for empty input string */
4652 /* handle empty field separator */
4654 {
4655 /* if first or last field, return input string, else empty string */
4658 else
4660 }
4662 /* find the first field separator */
4667 /* special case if fldsep not found at all */
4669 {
4671 /* if first or last field, return input string, else empty string */
4674 else
4676 }
4678 /*
4679 * take care of a negative field number (i.e. count from the right) by
4680 * converting to a positive field number; we need total number of fields
4681 */
4683 {
4684 /* we found a fldsep, so there are at least two fields */
4688 numfields++;
4690 /* special case of last field does not require an extra pass */
4692 {
4698 }
4700 /* else, convert fldnum to positive notation */
4703 /* if nonexistent field, return empty string */
4705 {
4708 }
4710 /* reset to pointing at first match, but now with positive fldnum */
4714 }
4716 /* identify bounds of first field */
4721 {
4722 /* identify bounds of next field */
4727 }
4732 {
4733 /* N'th field separator not found */
4734 /* if last field requested, return it, else empty string */
4736 {
4741 }
4742 else
4744 }
4745 else
4746 {
4747 /* non-last field requested */
4749 }
4752 }
4754 /*
4755 * Convenience function to return true when two text params are equal.
4756 */
4757 static bool
4759 {
4761 collid,
4764 }
4766 /*
4767 * text_to_array
4768 * parse input string and return text array of elements,
4769 * based on provided field separator
4770 */
4771 Datum
4773 {
4774 SplitTextOutputData tstate;
4776 /* For array output, tstate should start as all zeroes */
4786 CurrentMemoryContext));
4787 }
4789 /*
4790 * text_to_array_null
4791 * parse input string and return text array of elements,
4792 * based on provided field separator and null string
4793 *
4794 * This is a separate entry point only to prevent the regression tests from
4795 * complaining about different argument sets for the same internal function.
4796 */
4797 Datum
4799 {
4801 }
4803 /*
4804 * text_to_table
4805 * parse input string and return table of elements,
4806 * based on provided field separator
4807 */
4808 Datum
4810 {
4812 SplitTextOutputData tstate;
4822 }
4824 /*
4825 * text_to_table_null
4826 * parse input string and return table of elements,
4827 * based on provided field separator and null string
4828 *
4829 * This is a separate entry point only to prevent the regression tests from
4830 * complaining about different argument sets for the same internal function.
4831 */
4832 Datum
4834 {
4836 }
4838 /*
4839 * Common code for text_to_array, text_to_array_null, text_to_table
4840 * and text_to_table_null functions.
4841 *
4842 * These are not strict so we have to test for null inputs explicitly.
4843 * Returns false if result is to be null, else returns true.
4844 *
4845 * Note that if the result is valid but empty (zero elements), we return
4846 * without changing *tstate --- caller must handle that case, too.
4847 */
4848 static bool
4850 {
4860 /* when input string is NULL, then result is NULL too */
4866 /* fldsep can be NULL */
4869 else
4872 /* null_string can be NULL or omitted */
4875 else
4879 {
4880 /*
4881 * Normal case with non-null fldsep. Use the text_position machinery
4882 * to search for occurrences of fldsep.
4883 */
4884 TextPositionState state;
4889 /* return empty set for empty input string */
4893 /* empty field separator: return input string as a one-element set */
4895 {
4899 }
4906 {
4915 {
4916 /* fetch last field */
4919 }
4920 else
4921 {
4922 /* fetch non-last field */
4925 }
4927 /* build a temp text datum to pass to split_text_accum_result */
4930 /* stash away this field */
4940 }
4943 }
4944 else
4945 {
4946 /*
4947 * When fldsep is NULL, each character in the input string becomes a
4948 * separate element in the result set. The separator is effectively
4949 * the space between characters.
4950 */
4956 {
4961 /* build a temp text datum to pass to split_text_accum_result */
4964 /* stash away this field */
4972 }
4973 }
4976 }
4978 /*
4979 * Add text item to result set (table or array).
4980 *
4981 * This is also responsible for checking to see if the item matches
4982 * the null_string, in which case we should emit NULL instead.
4983 */
4984 static void
4988 Oid collation)
4989 {
4996 {
5005 values,
5006 nulls);
5007 }
5008 else
5009 {
5012 is_null,
5013 TEXTOID,
5014 CurrentMemoryContext);
5015 }
5016 }
5018 /*
5019 * array_to_text
5020 * concatenate Cstring representation of input array elements
5021 * using provided field separator
5022 */
5023 Datum
5025 {
5030 }
5032 /*
5033 * array_to_text_null
5034 * concatenate Cstring representation of input array elements
5035 * using provided field separator and null string
5036 *
5037 * This version is not strict so we have to test for null inputs explicitly.
5038 */
5039 Datum
5041 {
5046 /* returns NULL when first or second parameter is NULL */
5053 /* NULL null string is passed through as a null pointer */
5056 else
5060 }
5062 /*
5063 * common code for array_to_text and array_to_text_null functions
5064 */
5068 {
5072 ndims;
5073 Oid element_type;
5077 StringInfoData buf;
5089 /* if there are no elements, return an empty string */
5096 /*
5097 * We arrange to look up info about element type, including its output
5098 * conversion proc, only once per series of calls, assuming the element
5099 * type doesn't change underneath us.
5100 */
5103 {
5108 }
5111 {
5112 /*
5113 * Get info about element type, including its output conversion proc
5114 */
5122 }
5132 {
5133 Datum itemvalue;
5136 /* Get source element, checking for NULL */
5138 {
5139 /* if null_string is NULL, we just ignore null elements */
5141 {
5144 else
5147 }
5148 }
5149 else
5150 {
5157 else
5163 }
5165 /* advance bitmap pointer if any */
5167 {
5170 {
5171 bitmap++;
5173 }
5174 }
5175 }
5181 }
5183 #define HEXBASE 16
5184 /*
5185 * Convert an int32 to a string containing a base 16 (hex) representation of
5186 * the number.
5187 */
5188 Datum
5190 {
5199 do
5200 {
5206 }
5208 /*
5209 * Convert an int64 to a string containing a base 16 (hex) representation of
5210 * the number.
5211 */
5212 Datum
5214 {
5223 do
5224 {
5230 }
5232 /*
5233 * Return the size of a datum, possibly compressed
5234 *
5235 * Works on any data type
5236 */
5237 Datum
5239 {
5241 int32 result;
5244 /* On first call, get the input type's typlen, and save at *fn_extra */
5246 {
5247 /* Lookup the datatype of the supplied argument */
5257 }
5258 else
5262 {
5263 /* varlena type, possibly toasted */
5265 }
5267 {
5268 /* cstring */
5270 }
5271 else
5272 {
5273 /* ordinary fixed-width type */
5275 }
5278 }
5280 /*
5281 * Return the compression method stored in the compressed attribute. Return
5282 * NULL for non varlena type or uncompressed data.
5283 */
5284 Datum
5286 {
5289 ToastCompressionId cmid;
5291 /* On first call, get the input type's typlen, and save at *fn_extra */
5293 {
5294 /* Lookup the datatype of the supplied argument */
5304 }
5305 else
5311 /* get the compression method id stored in the compressed varlena */
5317 /* convert compression method id to compression method name */
5319 {
5328 }
5331 }
5333 /*
5334 * string_agg - Concatenates values and returns string.
5335 *
5336 * Syntax: string_agg(value text, delimiter text) RETURNS text
5337 *
5338 * Note: Any NULL values are ignored. The first-call delimiter isn't
5339 * actually used at all, and on subsequent calls the delimiter precedes
5340 * the associated value.
5341 */
5343 /* subroutine to initialize state */
5344 static StringInfo
5346 {
5347 StringInfo state;
5348 MemoryContext aggcontext;
5349 MemoryContext oldcontext;
5352 {
5353 /* cannot be called directly because of internal-type argument */
5355 }
5357 /*
5358 * Create state in aggregate context. It'll stay there across subsequent
5359 * calls.
5360 */
5366 }
5368 Datum
5370 {
5371 StringInfo state;
5375 /* Append the value unless null. */
5377 {
5378 /* On the first time through, we ignore the delimiter. */
5385 }
5387 /*
5388 * The transition type for string_agg() is declared to be "internal",
5389 * which is a pass-by-value type the same size as a pointer.
5390 */
5392 }
5394 Datum
5396 {
5397 StringInfo state;
5399 /* cannot be called directly because of internal-type argument */
5406 else
5408 }
5410 /*
5411 * Prepare cache with fmgr info for the output functions of the datatypes of
5412 * the arguments of a concat-like function, beginning with argument "argidx".
5413 * (Arguments before that will have corresponding slots in the resulting
5414 * FmgrInfo array, but we don't fill those slots.)
5415 */
5418 {
5422 /* We keep the info in fn_mcxt so it survives across calls */
5427 {
5428 Oid valtype;
5429 Oid typOutput;
5438 }
5443 }
5445 /*
5446 * Implementation of both concat() and concat_ws().
5447 *
5448 * sepstr is the separator string to place between values.
5449 * argidx identifies the first argument to concatenate (counting from zero);
5450 * note that this must be constant across any one series of calls.
5451 *
5452 * Returns NULL if result should be NULL, else text value.
5453 */
5456 FunctionCallInfo fcinfo)
5457 {
5459 StringInfoData str;
5464 /*
5465 * concat(VARIADIC some-array) is essentially equivalent to
5466 * array_to_text(), ie concat the array elements with the given separator.
5467 * So we just pass the case off to that code.
5468 */
5470 {
5473 /* Should have just the one argument */
5476 /* concat(VARIADIC NULL) is defined as NULL */
5480 /*
5481 * Non-null argument had better be an array. We assume that any call
5482 * context that could let get_fn_expr_variadic return true will have
5483 * checked that a VARIADIC-labeled parameter actually is an array. So
5484 * it should be okay to just Assert that it's an array rather than
5485 * doing a full-fledged error check.
5486 */
5489 /* OK, safe to fetch the array value */
5492 /*
5493 * And serialize the array. We tell array_to_text to ignore null
5494 * elements, which matches the behavior of the loop below.
5495 */
5497 }
5499 /* Normal case without explicit VARIADIC marker */
5502 /* Get output function info, building it if first time through */
5508 {
5510 {
5513 /* add separator if appropriate */
5516 else
5519 /* call the appropriate type output function, append the result */
5522 }
5523 }
5529 }
5531 /*
5532 * Concatenate all arguments. NULL arguments are ignored.
5533 */
5534 Datum
5536 {
5543 }
5545 /*
5546 * Concatenate all but first argument value with separators. The first
5547 * parameter is used as the separator. NULL arguments are ignored.
5548 */
5549 Datum
5551 {
5555 /* return NULL when separator is NULL */
5564 }
5566 /*
5567 * Return first n characters in the string. When n is negative,
5568 * return all but last |n| characters.
5569 */
5570 Datum
5572 {
5576 {
5585 }
5586 else
5588 }
5590 /*
5591 * Return last n characters in the string. When n is negative,
5592 * return all but first |n| characters.
5593 */
5594 Datum
5596 {
5605 else
5610 }
5612 /*
5613 * Return reversed string
5614 */
5615 Datum
5617 {
5630 {
5631 /* multibyte version */
5633 {
5640 }
5641 }
5642 else
5643 {
5644 /* single byte version */
5647 }
5650 }
5653 /*
5654 * Support macros for text_format()
5655 */
5658 #define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
5659 do { \
5660 if (++(ptr) >= (end_ptr)) \
5661 ereport(ERROR, \
5662 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
5665 } while (0)
5667 /*
5668 * Returns a formatted string
5669 */
5670 Datum
5672 {
5674 StringInfoData str;
5687 FmgrInfo typoutputfinfo;
5688 FmgrInfo typoutputinfo_width;
5690 /* When format string is null, immediately return null */
5694 /* If argument is marked VARIADIC, expand array into elements */
5696 {
5698 int16 elmlen;
5703 /* Should have just the one argument */
5706 /* If argument is NULL, we treat it as zero-length array */
5709 else
5710 {
5711 /*
5712 * Non-null argument had better be an array. We assume that any
5713 * call context that could let get_fn_expr_variadic return true
5714 * will have checked that a VARIADIC-labeled parameter actually is
5715 * an array. So it should be okay to just Assert that it's an
5716 * array rather than doing a full-fledged error check.
5717 */
5720 /* OK, safe to fetch the array value */
5723 /* Get info about array element type */
5728 /* Extract all array elements */
5731 }
5735 }
5736 else
5737 {
5738 /* Non-variadic case, we'll process the arguments individually */
5741 }
5743 /* Setup for main loop. */
5750 /* Scan format string, looking for conversion specifiers. */
5752 {
5757 Datum value;
5759 Oid typid;
5761 /*
5762 * If it's not the start of a conversion specifier, just copy it to
5763 * the output buffer.
5764 */
5766 {
5769 }
5773 /* Easy case: %% outputs a single % */
5775 {
5778 }
5780 /* Parse the optional portions of the format specifier */
5785 /*
5786 * Next we should see the main conversion specifier. Whether or not
5787 * an argument position was present, it's known that at least one
5788 * character remains in the string at this point. Experience suggests
5789 * that it's worth checking that that character is one of the expected
5790 * ones before we try to fetch arguments, so as to produce the least
5791 * confusing response to a mis-formatted specifier.
5792 */
5800 /* If indirect width was specified, get its value */
5802 {
5803 /* Collect the specified or next argument position */
5811 /* Get the value and type of the selected argument */
5813 {
5817 }
5818 else
5819 {
5823 }
5827 arg++;
5829 /* We can treat NULL width the same as zero */
5836 else
5837 {
5838 /* For less-usual datatypes, convert to text then to int */
5842 {
5843 Oid typoutputfunc;
5849 }
5853 /* pg_strtoint32 will complain about bad data or overflow */
5857 }
5858 }
5860 /* Collect the specified or next argument position */
5868 /* Get the value and type of the selected argument */
5870 {
5874 }
5875 else
5876 {
5880 }
5884 arg++;
5886 /*
5887 * Get the appropriate typOutput function, reusing previous one if
5888 * same type as previous argument. That's particularly useful in the
5889 * variadic-array case, but often saves work even for ordinary calls.
5890 */
5892 {
5893 Oid typoutputfunc;
5899 }
5901 /*
5902 * And now we can format the value.
5903 */
5905 {
5914 /* should not get here, because of previous check */
5921 }
5922 }
5924 /* Don't need deconstruct_array results anymore. */
5930 /* Generate results. */
5935 }
5937 /*
5938 * Parse contiguous digits as a decimal number.
5939 *
5940 * Returns true if some digits could be parsed.
5941 * The value is returned into *value, and *ptr is advanced to the next
5942 * character to be parsed.
5943 *
5944 * Note parsing invariant: at least one character is known available before
5945 * string end (end_ptr) at entry, and this is still true at exit.
5946 */
5947 static bool
5949 {
5955 {
5965 }
5971 }
5973 /*
5974 * Parse a format specifier (generally following the SUS printf spec).
5975 *
5976 * We have already advanced over the initial '%', and we are looking for
5977 * [argpos][flags][width]type (but the type character is not consumed here).
5978 *
5979 * Inputs are start_ptr (the position after '%') and end_ptr (string end + 1).
5980 * Output parameters:
5981 * argpos: argument position for value to be printed. -1 means unspecified.
5982 * widthpos: argument position for width. Zero means the argument position
5983 * was unspecified (ie, take the next arg) and -1 means no width
5984 * argument (width was omitted or specified as a constant).
5985 * flags: bitmask of flags.
5986 * width: directly-specified width value. Zero means the width was omitted
5987 * (note it's not necessary to distinguish this case from an explicit
5988 * zero width value).
5989 *
5990 * The function result is the next character position to be parsed, ie, the
5991 * location where the type character is/should be.
5992 *
5993 * Note parsing invariant: at least one character is known available before
5994 * string end (end_ptr) at entry, and this is still true at exit.
5995 */
6000 {
6004 /* set defaults for output parameters */
6010 /* try to identify first number */
6012 {
6014 {
6015 /* Must be just a width and a type, so we're done */
6018 }
6019 /* The number was argument position */
6021 /* Explicit 0 for argument index is immediately refused */
6027 }
6029 /* Handle flags (only minus is supported now) */
6031 {
6034 }
6037 {
6038 /* Handle indirect width */
6041 {
6042 /* number in this position must be closed by $ */
6047 /* The number was width argument position */
6049 /* Explicit 0 for argument index is immediately refused */
6055 }
6056 else
6058 }
6059 else
6060 {
6061 /* Check for direct width specification */
6064 }
6066 /* cp should now be pointing at type character */
6068 }
6070 /*
6071 * Format a %s, %I, or %L conversion
6072 */
6073 static void
6078 {
6081 /* Handle NULL arguments before trying to stringify the value. */
6083 {
6093 }
6095 /* Stringify. */
6098 /* Escape. */
6100 {
6101 /* quote_identifier may or may not allocate a new string. */
6103 }
6105 {
6109 /* quote_literal_cstr() always allocates a new string */
6111 }
6112 else
6115 /* Cleanup. */
6117 }
6119 /*
6120 * Append str to buf, padding as directed by flags/width
6121 */
6122 static void
6125 {
6129 /* fast path for typical easy case */
6131 {
6134 }
6137 {
6138 /* Negative width: implicit '-' flag, then take absolute value */
6140 /* -INT_MIN is undefined */
6146 }
6152 {
6153 /* left justify */
6157 }
6158 else
6159 {
6160 /* right justify */
6164 }
6165 }
6167 /*
6168 * text_format_nv - nonvariadic wrapper for text_format function.
6169 *
6170 * note: this wrapper is necessary to pass the sanity check in opr_sanity,
6171 * which checks that all built-in functions that share the implementing C
6172 * function take the same number of arguments.
6173 */
6174 Datum
6176 {
6178 }
6180 /*
6181 * Helper function for Levenshtein distance functions. Faster than memcmp(),
6182 * for this use case.
6183 */
6186 {
6188 {
6189 len--;
6192 }
6194 }
6196 /* Expand each Levenshtein distance variant */
6198 #define LEVENSHTEIN_LESS_EQUAL
6202 /*
6203 * The following *ClosestMatch() functions can be used to determine whether a
6204 * user-provided string resembles any known valid values, which is useful for
6205 * providing hints in log messages, among other things. Use these functions
6206 * like so:
6207 *
6208 * initClosestMatch(&state, source_string, max_distance);
6209 *
6210 * for (int i = 0; i < num_valid_strings; i++)
6211 * updateClosestMatch(&state, valid_strings[i]);
6212 *
6213 * closestMatch = getClosestMatch(&state);
6214 */
6216 /*
6217 * Initialize the given state with the source string and maximum Levenshtein
6218 * distance to consider.
6219 */
6220 void
6222 {
6230 }
6232 /*
6233 * If the candidate string is a closer match than the current one saved (or
6234 * there is no match saved), save it as the closest match.
6235 *
6236 * If the source or candidate string is NULL, empty, or too long, this function
6237 * takes no action. Likewise, if the Levenshtein distance exceeds the maximum
6238 * allowed or more than half the characters are different, no action is taken.
6239 */
6240 void
6242 {
6251 /*
6252 * To avoid ERROR-ing, we check the lengths here instead of setting
6253 * 'trusted' to false in the call to varstr_levenshtein_less_equal().
6254 */
6265 {
6268 }
6269 }
6271 /*
6272 * Return the closest match. If no suitable candidates were provided via
6273 * updateClosestMatch(), return NULL.
6274 */
6277 {
6281 }
6284 /*
6285 * Unicode support
6286 */
6288 static UnicodeNormalizationForm
6290 {
6293 /*
6294 * Might as well check this while we're here.
6295 */
6309 else
6315 }
6317 Datum
6319 {
6322 UnicodeNormalizationForm form;
6332 /* convert to pg_wchar */
6337 {
6340 }
6344 /* action */
6347 /* convert back to UTF-8 string */
6350 {
6355 }
6362 {
6365 }
6369 }
6371 /*
6372 * Check whether the string is in the specified Unicode normalization form.
6373 *
6374 * This is done by converting the string to the specified normal form and then
6375 * comparing that to the original string. To speed that up, we also apply the
6376 * "quick check" algorithm specified in UAX #15, which can give a yes or no
6377 * answer for many strings by just scanning the string once.
6378 *
6379 * This function should generally be optimized for the case where the string
6380 * is in fact normalized. In that case, we'll end up looking at the entire
6381 * string, so it's probably not worth doing any incremental conversion etc.
6382 */
6383 Datum
6385 {
6388 UnicodeNormalizationForm form;
6394 UnicodeNormalizationQC quickcheck;
6400 /* convert to pg_wchar */
6405 {
6408 }
6412 /* quick check (see UAX #15) */
6419 /* normalize and compare with original */
6424 output_size++;
6430 }
6432 /*
6433 * Check if first n chars are hexadecimal digits
6434 */
6435 static bool
6437 {
6443 }
6445 static unsigned int
6447 {
6456 }
6458 /*
6459 * Translate string with hexadecimal digits to number
6460 */
6461 static unsigned int
6463 {
6470 }
6472 /*
6473 * Replaces Unicode escape sequences by Unicode characters
6474 */
6475 Datum
6477 {
6481 StringInfoData str;
6492 {
6494 {
6497 {
6503 }
6506 {
6507 pg_wchar unicode;
6518 {
6520 {
6523 }
6524 else
6526 }
6532 else
6533 {
6536 }
6540 }
6542 {
6543 pg_wchar unicode;
6553 {
6555 {
6558 }
6559 else
6561 }
6567 else
6568 {
6571 }
6575 }
6577 {
6578 pg_wchar unicode;
6588 {
6590 {
6593 }
6594 else
6596 }
6602 else
6603 {
6606 }
6610 }
6611 else
6616 }
6617 else
6618 {
6623 len--;
6624 }
6625 }
6627 /* unfinished surrogate pair? */
6636 invalid_pair:
6641 }