114 #define TEXTBUFLEN 1024
116 #define DatumGetVarStringP(X) ((VarString *) PG_DETOAST_DATUM(X))
117 #define DatumGetVarStringPP(X) ((VarString *) PG_DETOAST_DATUM_PACKED(X))
132 bool length_not_specified);
147 bool length_not_specified);
156 const char *fldsep,
const char *null_string);
162 int *argpos,
int *widthpos,
163 int *flags,
int *width);
167 int flags,
int width);
169 int flags,
int width);
257 if (dst_len >= src_len)
265 if (srcunpacked != src)
275 #define VAL(CH) ((CH) - '0')
276 #define DIG(VAL) ((VAL) + '0')
293 Node *escontext = fcinfo->context;
300 if (inputText[0] ==
'\\' && inputText[1] ==
'x')
302 size_t len = strlen(inputText);
314 for (bc = 0, tp = inputText; *tp !=
'\0'; bc++)
318 else if ((tp[0] ==
'\\') &&
319 (tp[1] >=
'0' && tp[1] <=
'3') &&
320 (tp[2] >=
'0' && tp[2] <=
'7') &&
321 (tp[3] >=
'0' && tp[3] <=
'7'))
323 else if ((tp[0] ==
'\\') &&
332 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
333 errmsg(
"invalid input syntax for type %s",
"bytea")));
348 else if ((tp[0] ==
'\\') &&
349 (tp[1] >=
'0' && tp[1] <=
'3') &&
350 (tp[2] >=
'0' && tp[2] <=
'7') &&
351 (tp[3] >=
'0' && tp[3] <=
'7'))
357 *rp++ = bc +
VAL(tp[3]);
361 else if ((tp[0] ==
'\\') &&
373 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
374 errmsg(
"invalid input syntax for type %s",
"bytea")));
415 else if ((
unsigned char) *vp < 0x20 || (
unsigned char) *vp > 0x7e)
428 (
errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
440 else if ((
unsigned char) *vp < 0x20 || (
unsigned char) *vp > 0x7e)
459 elog(
ERROR,
"unrecognized bytea_output setting: %d",
477 nbytes =
buf->len -
buf->cursor;
508 bool isfirst =
false;
817 for (s = p; n > 0; n--)
903 if (length_not_specified)
910 (
errcode(ERRCODE_SUBSTRING_ERROR),
911 errmsg(
"negative substring length not allowed")));
966 if (length_not_specified)
968 slice_size = L1 = -1;
973 (
errcode(ERRCODE_SUBSTRING_ERROR),
974 errmsg(
"negative substring length not allowed")));
975 slice_size = L1 = -1;
983 slice_size = L1 = -1;
1036 if (S1 > slice_strlen)
1048 E1 =
Min(S1 + L1, slice_start + 1 + slice_strlen);
1050 E1 = slice_start + 1 + slice_strlen;
1056 for (
i = 0;
i < S1 - 1;
i++)
1066 for (
i = S1;
i < E1;
i++)
1071 memcpy(
VARDATA(ret), s, (p - s));
1079 elog(
ERROR,
"invalid backend encoding: encoding max length < 1");
1130 (
errcode(ERRCODE_SUBSTRING_ERROR),
1131 errmsg(
"negative substring length not allowed")));
1134 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1135 errmsg(
"integer out of range")));
1229 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1230 errmsg(
"nondeterministic collations are not supported for substring searches")));
1245 state->is_multibyte_char_in_char =
false;
1247 state->is_multibyte_char_in_char =
false;
1249 state->is_multibyte_char_in_char =
true;
1255 state->last_match = NULL;
1269 if (len1 >= len2 && len2 > 1)
1271 int searchlength = len1 - len2;
1275 const char *str2 =
state->str2;
1289 if (searchlength < 16)
1291 else if (searchlength < 64)
1293 else if (searchlength < 128)
1295 else if (searchlength < 512)
1297 else if (searchlength < 2048)
1299 else if (searchlength < 4096)
1300 skiptablemask = 127;
1302 skiptablemask = 255;
1303 state->skiptablemask = skiptablemask;
1310 for (
i = 0;
i <= skiptablemask;
i++)
1311 state->skiptable[
i] = len2;
1322 for (
i = 0;
i < last;
i++)
1323 state->skiptable[(
unsigned char) str2[
i] & skiptablemask] = last -
i;
1338 int needle_len =
state->len2;
1342 if (needle_len <= 0)
1346 if (
state->last_match)
1347 start_ptr =
state->last_match + needle_len;
1349 start_ptr =
state->str1;
1363 if (
state->is_multibyte_char_in_char)
1370 while (
state->refpoint < matchptr)
1382 if (
state->refpoint > matchptr)
1384 start_ptr =
state->refpoint;
1390 state->last_match = matchptr;
1402 int haystack_len =
state->len1;
1403 int needle_len =
state->len2;
1404 int skiptablemask =
state->skiptablemask;
1405 const char *haystack =
state->str1;
1406 const char *needle =
state->str2;
1407 const char *haystack_end = &haystack[haystack_len];
1410 Assert(start_ptr >= haystack && start_ptr <= haystack_end);
1412 if (needle_len == 1)
1415 char nchar = *needle;
1418 while (hptr < haystack_end)
1421 return (
char *) hptr;
1427 const char *needle_last = &needle[needle_len - 1];
1430 hptr = start_ptr + needle_len - 1;
1431 while (hptr < haystack_end)
1455 hptr +=
state->skiptable[(
unsigned char) *hptr & skiptablemask];
1470 return state->last_match;
1485 return state->refpos + 1;
1497 state->last_match = NULL;
1519 (
errcode(ERRCODE_INDETERMINATE_COLLATION),
1520 errmsg(
"could not determine which collation to use for string comparison"),
1521 errhint(
"Use the COLLATE clause to set the collation explicitly.")));
1553 result = memcmp(arg1, arg2,
Min(len1, len2));
1554 if ((result == 0) && (len1 != len2))
1555 result = (len1 < len2) ? -1 : 1;
1572 if (len1 == len2 && memcmp(arg1, arg2, len1) == 0)
1575 result =
pg_strncoll(arg1, len1, arg2, len2, mylocale);
1580 result = memcmp(arg1, arg2,
Min(len1, len2));
1581 if ((result == 0) && (len1 != len2))
1582 result = (len1 < len2) ? -1 : 1;
1622 bool locale_is_c =
false;
1681 bool locale_is_c =
false;
1808 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1809 errmsg(
"nondeterministic collations are not supported for substring searches")));
1876 bool collate_c =
false;
1897 if (typid == BPCHAROID)
1899 else if (typid == NAMEOID)
1922 if (typid == NAMEOID)
1957 if (abbreviate || !collate_c)
2028 result = memcmp(a1p, a2p,
Min(len1, len2));
2029 if ((result == 0) && (len1 != len2))
2030 result = (len1 < len2) ? -1 : 1;
2065 result = memcmp(a1p, a2p,
Min(len1, len2));
2066 if ((result == 0) && (len1 != len2))
2067 result = (len1 < len2) ? -1 : 1;
2146 if (len1 == len2 && memcmp(a1p, a2p, len1) == 0)
2164 if (sss->
typid == BPCHAROID)
2193 if (len1 != sss->
last_len1 || memcmp(sss->
buf1, a1p, len1) != 0)
2196 memcpy(sss->
buf1, a1p, len1);
2197 sss->
buf1[len1] =
'\0';
2207 if (len2 != sss->
last_len2 || memcmp(sss->
buf2, a2p, len2) != 0)
2209 memcpy(sss->
buf2, a2p, len2);
2210 sss->
buf2[len2] =
'\0';
2223 result = strcmp(sss->
buf1, sss->
buf2);
2241 const size_t max_prefix_bytes =
sizeof(
Datum);
2244 char *authoritative_data =
VARDATA_ANY(authoritative);
2252 pres = (
char *) &
res;
2254 memset(pres, 0, max_prefix_bytes);
2258 if (sss->
typid == BPCHAROID)
2289 memcpy(pres, authoritative_data,
Min(
len, max_prefix_bytes));
2308 memcmp(sss->
buf1, authoritative_data,
len) == 0)
2315 memcpy(sss->
buf1, authoritative_data,
len);
2325 if (sss->
buflen2 < max_prefix_bytes)
2333 max_prefix_bytes, sss->
locale);
2351 if (bsize < sss->buflen2)
2372 memcpy(pres, sss->
buf2,
Min(max_prefix_bytes, bsize));
2395 #if SIZEOF_DATUM == 8
2422 res = DatumBigEndianToNative(
res);
2426 pfree(authoritative);
2440 double abbrev_distinct,
2446 if (memtupcount < 100)
2457 if (abbrev_distinct <= 1.0)
2458 abbrev_distinct = 1.0;
2460 if (key_distinct <= 1.0)
2471 double norm_abbrev_card = abbrev_distinct / (double) memtupcount;
2473 elog(
LOG,
"varstr_abbrev: abbrev_distinct after %d: %f "
2474 "(key_distinct: %f, norm_abbrev_card: %f, prop_card: %f)",
2475 memtupcount, abbrev_distinct, key_distinct, norm_abbrev_card,
2496 if (abbrev_distinct > key_distinct * sss->
prop_card)
2523 if (memtupcount > 10000)
2542 elog(
LOG,
"varstr_abbrev: aborted abbreviation at %d "
2543 "(abbrev_distinct: %f, key_distinct: %f, prop_card: %f)",
2544 memtupcount, abbrev_distinct, key_distinct, sss->
prop_card);
2563 collid == DEFAULT_COLLATION_OID ||
2604 size_t len1 = strlen(
NameStr(*arg1));
2611 if (
collid == C_COLLATION_OID)
2612 result = (len1 == len2 &&
2630 size_t len2 = strlen(
NameStr(*arg2));
2636 if (
collid == C_COLLATION_OID)
2637 result = (len1 == len2 &&
2654 size_t len1 = strlen(
NameStr(*arg1));
2661 if (
collid == C_COLLATION_OID)
2662 result = !(len1 == len2 &&
2680 size_t len2 = strlen(
NameStr(*arg2));
2686 if (
collid == C_COLLATION_OID)
2687 result = !(len1 == len2 &&
2731 #define CmpCall(cmpfunc) \
2732 DatumGetInt32(DirectFunctionCall2Coll(cmpfunc, \
2733 PG_GET_COLLATION(), \
2734 PG_GETARG_DATUM(0), \
2735 PG_GETARG_DATUM(1)))
2809 else if (len1 < len2)
2811 else if (len1 > len2)
2986 #define PG_STR_GET_BYTEA(str_) \
2987 DatumGetByteaPP(DirectFunctionCall1(byteain, CStringGetDatum(str_)))
3031 bool length_not_specified)
3042 if (length_not_specified)
3054 (
errcode(ERRCODE_SUBSTRING_ERROR),
3055 errmsg(
"negative substring length not allowed")));
3132 (
errcode(ERRCODE_SUBSTRING_ERROR),
3133 errmsg(
"negative substring length not allowed")));
3136 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3137 errmsg(
"integer out of range")));
3188 for (p = 0; p <=
px; p++)
3190 if ((*
p2 == *p1) && (memcmp(p1,
p2, len2) == 0))
3218 if (n < 0 || n >=
len)
3220 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3221 errmsg(
"index %d out of valid range, 0..%d",
3249 if (n < 0 || n >= (int64)
len * 8)
3251 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3252 errmsg(
"index %lld out of valid range, 0..%lld",
3253 (
long long) n, (
long long)
len * 8 - 1)));
3256 byteNo = (int) (n / 8);
3257 bitNo = (int) (n % 8);
3259 byte = ((
unsigned char *)
VARDATA_ANY(v))[byteNo];
3261 if (
byte & (1 << bitNo))
3285 if (n < 0 || n >=
len)
3287 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3288 errmsg(
"index %d out of valid range, 0..%d",
3294 ((
unsigned char *)
VARDATA(
res))[n] = newByte;
3321 if (n < 0 || n >= (int64)
len * 8)
3323 (
errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
3324 errmsg(
"index %lld out of valid range, 0..%lld",
3325 (
long long) n, (
long long)
len * 8 - 1)));
3328 byteNo = (int) (n / 8);
3329 bitNo = (int) (n % 8);
3334 if (newBit != 0 && newBit != 1)
3336 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3337 errmsg(
"new bit must be 0 or 1")));
3342 oldByte = ((
unsigned char *)
VARDATA(
res))[byteNo];
3345 newByte = oldByte & (~(1 << bitNo));
3347 newByte = oldByte | (1 << bitNo);
3349 ((
unsigned char *)
VARDATA(
res))[byteNo] = newByte;
3412 (
errcode(ERRCODE_INVALID_NAME),
3413 errmsg(
"invalid name syntax")));
3415 if (namelist ==
NIL)
3417 (
errcode(ERRCODE_INVALID_NAME),
3418 errmsg(
"invalid name syntax")));
3420 foreach(l, namelist)
3422 char *curname = (
char *)
lfirst(l);
3460 char *nextp = rawstring;
3480 curname = nextp + 1;
3483 endp = strchr(nextp + 1,
'"');
3489 memmove(endp, endp + 1, strlen(endp));
3506 if (curname == nextp)
3518 len = endp - curname;
3521 strncpy(curname, downname,
len);
3535 else if (*nextp ==
'\0')
3549 *namelist =
lappend(*namelist, curname);
3587 char *nextp = rawstring;
3607 curname = nextp + 1;
3610 endp = strchr(nextp + 1,
'"');
3616 memmove(endp, endp + 1, strlen(endp));
3625 curname = endp = nextp;
3633 if (curname == endp)
3647 else if (*nextp ==
'\0')
3664 *namelist =
lappend(*namelist, curname);
3708 char *nextp = rawstring;
3728 curname = nextp + 1;
3731 endp = strchr(nextp + 1,
'"');
3737 memmove(endp, endp + 1, strlen(endp));
3751 if (curname == nextp)
3765 else if (*nextp ==
'\0')
3776 *namelist =
lappend(*namelist, curname);
3950 if ((
cmp == 0) && (len1 != len2))
3951 cmp = (len1 < len2) ? -1 : 1;
4002 int from_sub_text_len;
4015 if (src_text_len < 1 || from_sub_text_len < 1)
4040 chunk_len = curr_ptr - start_ptr;
4045 start_ptr = curr_ptr + from_sub_text_len;
4054 chunk_len = ((
char *) src_text +
VARSIZE_ANY(src_text)) - start_ptr;
4082 p = memchr(p,
'\\', p_end - p);
4089 if (*p >=
'1' && *p <=
'9')
4108 char *start_ptr,
int data_pos)
4115 const char *chunk_start = p;
4120 p = memchr(p,
'\\', p_end - p);
4125 if (p > chunk_start)
4140 if (*p >=
'1' && *p <=
'9')
4152 so = pmatch[0].
rm_so;
4153 eo = pmatch[0].
rm_eo;
4156 else if (*p ==
'\\')
4174 if (so >= 0 && eo >= 0)
4184 chunk_start = start_ptr;
4208 int cflags,
Oid collation,
4209 int search_start,
int n)
4234 if (escape_status < 2)
4248 while (search_start <= data_len)
4270 pg_regerror(regexec_result, re, errMsg,
sizeof(errMsg));
4272 (
errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
4273 errmsg(
"regular expression failed: %s", errMsg)));
4280 if (n > 0 && nmatches != n)
4287 search_start = pmatch[0].
rm_eo;
4288 if (pmatch[0].rm_so == pmatch[0].rm_eo)
4297 if (pmatch[0].rm_so - data_pos > 0)
4302 pmatch[0].rm_so - data_pos);
4309 start_ptr += chunk_len;
4310 data_pos = pmatch[0].
rm_so;
4316 if (escape_status > 0)
4318 start_ptr, data_pos);
4324 pmatch[0].rm_eo - data_pos);
4325 data_pos = pmatch[0].
rm_eo;
4339 search_start = data_pos;
4340 if (pmatch[0].rm_so == pmatch[0].rm_eo)
4347 if (data_pos < data_len)
4351 chunk_len = ((
char *) src_text +
VARSIZE_ANY(src_text)) - start_ptr;
4373 int inputstring_len;
4384 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4385 errmsg(
"field position must not be zero")));
4391 if (inputstring_len < 1)
4398 if (fldnum == 1 || fldnum == -1)
4414 if (fldnum == 1 || fldnum == -1)
4436 end_ptr =
VARDATA_ANY(inputstring) + inputstring_len;
4439 end_ptr - start_ptr));
4443 fldnum += numfields + 1;
4462 while (found && --fldnum > 0)
4465 start_ptr = end_ptr + fldsep_len;
4479 int last_len = start_ptr -
VARDATA_ANY(inputstring);
4482 inputstring_len - last_len);
4519 memset(&tstate, 0,
sizeof(tstate));
4524 if (tstate.
astate == NULL)
4559 tstate.tupdesc = rsi->
setDesc;
4597 int inputstring_len;
4632 if (inputstring_len < 1)
4639 null_string, collation);
4659 chunk_len = ((
char *) inputstring +
VARSIZE_ANY(inputstring)) - start_ptr;
4666 chunk_len = end_ptr - start_ptr;
4674 null_string, collation);
4681 start_ptr = end_ptr + fldsep_len;
4697 while (inputstring_len > 0)
4699 int chunk_len =
pg_mblen(start_ptr);
4708 null_string, collation);
4712 start_ptr += chunk_len;
4713 inputstring_len -= chunk_len;
4732 bool is_null =
false;
4734 if (null_string &&
text_isequal(field_value, null_string, collation))
4809 const char *fldsep,
const char *null_string)
4820 bool printed =
false;
4844 if (my_extra == NULL)
4865 typlen = my_extra->
typlen;
4879 if (bitmap && (*bitmap & bitmask) == 0)
4882 if (null_string != NULL)
4893 itemvalue =
fetch_att(p, typbyval, typlen);
4911 if (bitmask == 0x100)
4929 static inline text *
4932 const char *
digits =
"0123456789abcdef";
4936 char *
const end =
buf +
sizeof(
buf);
5021 if (fcinfo->flinfo->fn_extra == NULL)
5028 elog(
ERROR,
"cache lookup failed for type %u", argtypeid);
5032 *((
int *) fcinfo->flinfo->fn_extra) = typlen;
5035 typlen = *((
int *) fcinfo->flinfo->fn_extra);
5042 else if (typlen == -2)
5068 if (fcinfo->flinfo->fn_extra == NULL)
5075 elog(
ERROR,
"cache lookup failed for type %u", argtypeid);
5079 *((
int *) fcinfo->flinfo->fn_extra) = typlen;
5082 typlen = *((
int *) fcinfo->flinfo->fn_extra);
5103 elog(
ERROR,
"invalid compression method id %d", cmid);
5121 if (fcinfo->flinfo->fn_extra == NULL)
5128 elog(
ERROR,
"cache lookup failed for type %u", argtypeid);
5132 *((
int *) fcinfo->flinfo->fn_extra) = typlen;
5135 typlen = *((
int *) fcinfo->flinfo->fn_extra);
5171 elog(
ERROR,
"string_agg_transfn called in non-aggregate context");
5196 bool isfirst =
false;
5248 elog(
ERROR,
"aggregate function called in non-aggregate context");
5275 else if (state2->
len > 0)
5401 elog(
ERROR,
"could not determine data type of concat() input");
5428 bool first_arg =
true;
5471 if (foutcache == NULL)
5588 const char *endp = p +
len;
5623 #define TEXT_FORMAT_FLAG_MINUS 0x0001
5625 #define ADVANCE_PARSE_POINTER(ptr,end_ptr) \
5627 if (++(ptr) >= (end_ptr)) \
5629 (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
5630 errmsg("unterminated format() type specifier"), \
5631 errhint("For a single \"%%\" use \"%%%%\"."))); \
5643 const char *start_ptr;
5644 const char *end_ptr;
5649 Datum *elements = NULL;
5693 &elmlen, &elmbyval, &elmalign);
5697 &elements, &nulls, &
nitems);
5701 funcvariadic =
true;
5707 funcvariadic =
false;
5718 for (cp = start_ptr; cp < end_ptr; cp++)
5760 if (strchr(
"sIL", *cp) == NULL)
5762 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5763 errmsg(
"unrecognized format() type specifier \"%.*s\"",
5765 errhint(
"For a single \"%%\" use \"%%%%\".")));
5775 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5776 errmsg(
"too few arguments for format()")));
5788 isNull = nulls[
arg - 1];
5789 typid = element_type;
5792 elog(
ERROR,
"could not determine data type of format() input");
5799 else if (typid == INT4OID)
5801 else if (typid == INT2OID)
5808 if (typid != prev_width_type)
5814 fmgr_info(typoutputfunc, &typoutputinfo_width);
5815 prev_width_type = typid;
5832 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5833 errmsg(
"too few arguments for format()")));
5845 isNull = nulls[
arg - 1];
5846 typid = element_type;
5849 elog(
ERROR,
"could not determine data type of format() input");
5858 if (typid != prev_type)
5864 fmgr_info(typoutputfunc, &typoutputfinfo);
5883 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5884 errmsg(
"unrecognized format() type specifier \"%.*s\"",
5886 errhint(
"For a single \"%%\" use \"%%%%\".")));
5892 if (elements != NULL)
5918 const char *cp = *ptr;
5921 while (*cp >=
'0' && *cp <=
'9')
5923 int8 digit = (*cp -
'0');
5928 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
5929 errmsg(
"number is out of range")));
5965 int *argpos,
int *widthpos,
5966 int *flags,
int *width)
5968 const char *cp = start_ptr;
5991 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
5992 errmsg(
"format specifies argument 0, but arguments are numbered from 1")));
6012 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6013 errmsg(
"width argument position must be ended by \"$\"")));
6019 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6020 errmsg(
"format specifies argument 0, but arguments are numbered from 1")));
6044 int flags,
int width)
6051 if (conversion ==
's')
6053 else if (conversion ==
'L')
6055 else if (conversion ==
'I')
6057 (
errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
6058 errmsg(
"null values cannot be formatted as an SQL identifier")));
6066 if (conversion ==
'I')
6071 else if (conversion ==
'L')
6091 int flags,
int width)
6093 bool align_to_left =
false;
6106 align_to_left =
true;
6108 if (width <= INT_MIN)
6110 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
6111 errmsg(
"number is out of range")));
6115 align_to_left =
true;
6165 #define LEVENSHTEIN_LESS_EQUAL
6195 state->max_d = max_d;
6196 state->match = NULL;
6214 if (
state->source == NULL ||
state->source[0] ==
'\0' ||
6215 candidate == NULL || candidate[0] ==
'\0')
6227 candidate, strlen(candidate), 1, 1, 1,
6228 state->max_d,
true);
6229 if (dist <= state->max_d &&
6230 dist <= strlen(
state->source) / 2 &&
6231 (
state->min_d == -1 || dist < state->min_d))
6233 state->min_d = dist;
6234 state->match = candidate;
6247 return state->match;
6265 (
errcode(ERRCODE_SYNTAX_ERROR),
6266 errmsg(
"Unicode normalization can only be performed if server encoding is UTF8")));
6278 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6279 errmsg(
"invalid normalization form: %s", formstr)));
6324 (
errmsg(
"Unicode categorization can only be performed if server encoding is UTF8")));
6329 for (
int i = 0;
i <
size;
i++)
6375 for (
pg_wchar *wp = output_chars; *wp; wp++)
6377 unsigned char buf[4];
6387 for (
pg_wchar *wp = output_chars; *wp; wp++)
6449 for (
pg_wchar *wp = output_chars; *wp; wp++)
6452 result = (
size == output_size) &&
6453 (memcmp(input_chars, output_chars,
size *
sizeof(
pg_wchar)) == 0);
6464 for (
size_t i = 0;
i < n;
i++)
6465 if (!isxdigit((
unsigned char) instr[
i]))
6474 if (
c >=
'0' &&
c <=
'9')
6476 if (
c >=
'a' &&
c <=
'f')
6477 return c -
'a' + 0xA;
6478 if (
c >=
'A' &&
c <=
'F')
6479 return c -
'A' + 0xA;
6480 elog(
ERROR,
"invalid hexadecimal digit");
6490 unsigned int result = 0;
6492 for (
size_t i = 0;
i < n;
i++)
6493 result +=
hexval(instr[
i]) << (4 * (n -
i - 1));
6519 if (instr[0] ==
'\\')
6534 int offset = instr[1] ==
'u' ? 2 : 1;
6536 unicode =
hexval_n(instr + offset, 4);
6540 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6541 errmsg(
"invalid Unicode code point: %04X", unicode));
6557 pair_first = unicode;
6564 instr += 4 + offset;
6567 else if (
len >= 8 && instr[1] ==
'+' &&
isxdigits_n(instr + 2, 6))
6575 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6576 errmsg(
"invalid Unicode code point: %04X", unicode));
6592 pair_first = unicode;
6602 else if (
len >= 10 && instr[1] ==
'U' &&
isxdigits_n(instr + 2, 8))
6610 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
6611 errmsg(
"invalid Unicode code point: %04X", unicode));
6627 pair_first = unicode;
6639 (
errcode(ERRCODE_SYNTAX_ERROR),
6640 errmsg(
"invalid Unicode escape"),
6641 errhint(
"Unicode escapes must be \\XXXX, \\+XXXXXX, \\uXXXX, or \\UXXXXXXXX.")));
6664 (
errcode(ERRCODE_SYNTAX_ERROR),
6665 errmsg(
"invalid Unicode surrogate pair")));
Datum idx(PG_FUNCTION_ARGS)
#define PG_GETARG_ARRAYTYPE_P(n)
#define ARR_NULLBITMAP(a)
#define PG_RETURN_ARRAYTYPE_P(x)
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
ArrayType * construct_empty_array(Oid elmtype)
void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
int ArrayGetNItems(int ndim, const int *dims)
static Datum values[MAXATTR]
#define TextDatumGetCString(d)
#define unconstify(underlying_type, expr)
#define Assert(condition)
#define OidIsValid(objectId)
static void PGresult const char * p2
static void PGresult * res
Size toast_datum_size(Datum value)
Size toast_raw_datum_size(Datum value)
#define VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr)
int errmsg_internal(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereturn(context, dummy_value,...)
#define ereport(elevel,...)
uint64 hex_decode_safe(const char *src, size_t len, char *dst, Node *escontext)
uint64 hex_encode(const char *src, size_t len, char *dst)
struct varlena * pg_detoast_datum_packed(struct varlena *datum)
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Datum DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2)
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
bool get_fn_expr_variadic(FmgrInfo *flinfo)
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
#define PG_FREE_IF_COPY(ptr, n)
#define DatumGetByteaPSlice(X, m, n)
#define PG_GETARG_BYTEA_PP(n)
#define PG_GETARG_TEXT_PP(n)
#define PG_RETURN_BYTEA_P(x)
#define DatumGetByteaPP(X)
#define DatumGetTextPP(X)
#define DatumGetBpCharPP(X)
#define PG_GETARG_POINTER(n)
#define PG_RETURN_CSTRING(x)
#define PG_RETURN_INT64(x)
#define PG_GETARG_DATUM(n)
#define PG_GETARG_CSTRING(n)
#define PG_GETARG_INT64(n)
#define PG_GETARG_NAME(n)
#define PG_RETURN_TEXT_P(x)
#define DatumGetTextPSlice(X, m, n)
#define PG_RETURN_INT32(x)
#define PG_RETURN_NAME(x)
#define PG_GETARG_INT32(n)
#define PG_RETURN_DATUM(x)
#define PG_RETURN_POINTER(x)
#define PG_GET_COLLATION()
#define PG_GETARG_BYTEA_P_COPY(n)
#define PG_RETURN_BOOL(x)
void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags)
#define MAT_SRF_USE_EXPECTED_DESC
void px(PlannerInfo *root, Gene *tour1, Gene *tour2, Gene *offspring, int num_gene, City *city_table)
static Datum hash_uint32(uint32 k)
static Datum hash_any(const unsigned char *k, int keylen)
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
double estimateHyperLogLog(hyperLogLogState *cState)
void addHyperLogLog(hyperLogLogState *cState, uint32 hash)
static bool pg_mul_s32_overflow(int32 a, int32 b, int32 *result)
static bool pg_add_s32_overflow(int32 a, int32 b, int32 *result)
if(TABLE==NULL||TABLE_index==NULL)
#define MAX_LEVENSHTEIN_STRLEN
static void const char * fmt
List * lappend(List *list, void *datum)
void list_free(List *list)
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
bool get_collation_isdeterministic(Oid colloid)
void get_type_io_data(Oid typid, IOFuncSelector which_func, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *func)
int16 get_typlen(Oid typid)
Oid get_base_element_type(Oid typid)
static pg_wchar utf8_to_unicode(const unsigned char *c)
int GetDatabaseEncoding(void)
int pg_mbstrlen_with_len(const char *mbstr, int limit)
int pg_mbcharcliplen(const char *mbstr, int len, int limit)
int pg_mbstrlen(const char *mbstr)
int pg_mbcliplen(const char *mbstr, int len, int limit)
void pg_unicode_to_server(pg_wchar c, unsigned char *s)
int pg_database_encoding_max_length(void)
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
int pg_mblen(const char *mbstr)
char * pstrdup(const char *in)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
void * repalloc(void *pointer, Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
#define CHECK_FOR_INTERRUPTS()
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
int32 pg_strtoint32(const char *s)
static uint64 pg_popcount(const char *buf, int bytes)
#define PG_CACHE_LINE_SIZE
bool pg_strxfrm_enabled(pg_locale_t locale)
int pg_strncoll(const char *arg1, size_t len1, const char *arg2, size_t len2, pg_locale_t locale)
bool lc_collate_is_c(Oid collation)
pg_locale_t pg_newlocale_from_collation(Oid collid)
bool pg_locale_deterministic(pg_locale_t locale)
int pg_strcoll(const char *arg1, const char *arg2, pg_locale_t locale)
bool pg_strxfrm_prefix_enabled(pg_locale_t locale)
size_t pg_strxfrm(char *dest, const char *src, size_t destsize, pg_locale_t locale)
size_t pg_strxfrm_prefix(char *dest, const char *src, size_t destsize, pg_locale_t locale)
static rewind_source * source
static unsigned char * unicode_to_utf8(pg_wchar c, unsigned char *utf8string)
#define MAX_UNICODE_EQUIVALENT_STRING
static bool is_valid_unicode_codepoint(pg_wchar c)
static pg_wchar surrogate_pair_to_codepoint(pg_wchar first, pg_wchar second)
static bool is_utf16_surrogate_first(pg_wchar c)
static bool is_utf16_surrogate_second(pg_wchar c)
int pg_strcasecmp(const char *s1, const char *s2)
void canonicalize_path(char *path)
static uint32 DatumGetUInt32(Datum X)
static bool DatumGetBool(Datum X)
static Datum PointerGetDatum(const void *X)
static Name DatumGetName(Datum X)
static char * DatumGetCString(Datum X)
static Pointer DatumGetPointer(Datum X)
static int16 DatumGetInt16(Datum X)
static int32 DatumGetInt32(Datum X)
char * quote_literal_cstr(const char *rawstr)
MemoryContextSwitchTo(old_ctx)
static int cmp(const chr *x, const chr *y, size_t len)
static unsigned hash(unsigned *uv, int n)
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
int pg_regexec(regex_t *re, const chr *string, size_t len, size_t search_start, rm_detail_t *details, size_t nmatch, regmatch_t pmatch[], int flags)
regex_t * RE_compile_and_cache(text *text_re, int cflags, Oid collation)
const char * quote_identifier(const char *ident)
void truncate_identifier(char *ident, int len, bool warn)
bool scanner_isspace(char ch)
char * downcase_truncate_identifier(const char *ident, int len, bool warn)
static pg_noinline void Size size
struct SortSupportData * SortSupport
StringInfo makeStringInfo(void)
void appendStringInfo(StringInfo str, const char *fmt,...)
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
void appendStringInfoSpaces(StringInfo str, int count)
void appendStringInfoString(StringInfo str, const char *s)
void appendStringInfoChar(StringInfo str, char ch)
void initStringInfo(StringInfo str)
StringInfoData * StringInfo
#define appendStringInfoCharMacro(str, ch)
static void initReadOnlyStringInfo(StringInfo str, char *data, int len)
Tuplestorestate * setResult
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Datum(* abbrev_converter)(Datum original, SortSupport ssup)
int(* abbrev_full_comparator)(Datum x, Datum y, SortSupport ssup)
bool(* abbrev_abort)(int memtupcount, SortSupport ssup)
Tuplestorestate * tupstore
bool is_multibyte_char_in_char
hyperLogLogState full_card
hyperLogLogState abbr_card
ToastCompressionId toast_get_compression_id(struct varlena *attr)
@ TOAST_INVALID_COMPRESSION_ID
@ TOAST_LZ4_COMPRESSION_ID
@ TOAST_PGLZ_COMPRESSION_ID
int ssup_datum_unsigned_cmp(Datum x, Datum y, SortSupport ssup)
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)
#define att_align_nominal(cur_offset, attalign)
#define att_addlength_pointer(cur_offset, attlen, attptr)
static Datum fetch_att(const void *T, bool attbyval, int attlen)
pg_unicode_category unicode_category(pg_wchar code)
UnicodeNormalizationQC unicode_is_normalized_quickcheck(UnicodeNormalizationForm form, const pg_wchar *input)
pg_wchar * unicode_normalize(UnicodeNormalizationForm form, const pg_wchar *input)
#define PG_UNICODE_VERSION
String * makeString(char *str)
#define VARATT_IS_EXTERNAL_ONDISK(PTR)
#define VARATT_IS_COMPRESSED(PTR)
#define SET_VARSIZE(PTR, len)
#define VARATT_IS_EXTERNAL(PTR)
#define VARSIZE_ANY_EXHDR(PTR)
int bpchartruelen(char *s, int len)
static int varstrfastcmp_locale(char *a1p, int len1, char *a2p, int len2, SortSupport ssup)
static text * convert_to_base(uint64 value, int base)
Datum byteacat(PG_FUNCTION_ARGS)
List * textToQualifiedNameList(text *textval)
Datum unknownrecv(PG_FUNCTION_ARGS)
Datum array_to_text(PG_FUNCTION_ARGS)
Datum byteaoverlay(PG_FUNCTION_ARGS)
static int text_cmp(text *arg1, text *arg2, Oid collid)
Datum textsend(PG_FUNCTION_ARGS)
Datum textoverlay_no_len(PG_FUNCTION_ARGS)
static void text_format_string_conversion(StringInfo buf, char conversion, FmgrInfo *typOutputInfo, Datum value, bool isNull, int flags, int width)
const char * getClosestMatch(ClosestMatchState *state)
static text * text_overlay(text *t1, text *t2, int sp, int sl)
Datum text_format(PG_FUNCTION_ARGS)
Datum textlen(PG_FUNCTION_ARGS)
Datum pg_column_toast_chunk_id(PG_FUNCTION_ARGS)
static void text_position_setup(text *t1, text *t2, Oid collid, TextPositionState *state)
static int32 text_length(Datum str)
static bool varstr_abbrev_abort(int memtupcount, SortSupport ssup)
Datum byteaeq(PG_FUNCTION_ARGS)
Datum text_left(PG_FUNCTION_ARGS)
Datum byteagt(PG_FUNCTION_ARGS)
Datum string_agg_transfn(PG_FUNCTION_ARGS)
static bool text_isequal(text *txt1, text *txt2, Oid collid)
static void text_position_cleanup(TextPositionState *state)
static text * text_catenate(text *t1, text *t2)
static void appendStringInfoText(StringInfo str, const text *t)
Datum textgtname(PG_FUNCTION_ARGS)
Datum textout(PG_FUNCTION_ARGS)
Datum textcat(PG_FUNCTION_ARGS)
Datum text_substr(PG_FUNCTION_ARGS)
Datum bytea_string_agg_finalfn(PG_FUNCTION_ARGS)
Datum text_smaller(PG_FUNCTION_ARGS)
static text * text_substring(Datum str, int32 start, int32 length, bool length_not_specified)
static int check_replace_text_has_escape(const text *replace_text)
Datum text_concat_ws(PG_FUNCTION_ARGS)
static int internal_text_pattern_compare(text *arg1, text *arg2)
Datum string_agg_serialize(PG_FUNCTION_ARGS)
Datum text_ge(PG_FUNCTION_ARGS)
static int varlenafastcmp_locale(Datum x, Datum y, SortSupport ssup)
Datum array_to_text_null(PG_FUNCTION_ARGS)
static const char * text_format_parse_format(const char *start_ptr, const char *end_ptr, int *argpos, int *widthpos, int *flags, int *width)
Datum text_larger(PG_FUNCTION_ARGS)
Datum byteapos(PG_FUNCTION_ARGS)
Datum unicode_assigned(PG_FUNCTION_ARGS)
static bytea * bytea_overlay(bytea *t1, bytea *t2, int sp, int sl)
int varstr_cmp(const char *arg1, int len1, const char *arg2, int len2, Oid collid)
static char * text_position_get_match_ptr(TextPositionState *state)
static int bpcharfastcmp_c(Datum x, Datum y, SortSupport ssup)
Datum text_to_array_null(PG_FUNCTION_ARGS)
static unsigned int hexval_n(const char *instr, size_t n)
Datum byteane(PG_FUNCTION_ARGS)
static bool rest_of_char_same(const char *s1, const char *s2, int len)
Datum byteage(PG_FUNCTION_ARGS)
Datum byteacmp(PG_FUNCTION_ARGS)
Datum text_to_table_null(PG_FUNCTION_ARGS)
Datum text_right(PG_FUNCTION_ARGS)
Datum textne(PG_FUNCTION_ARGS)
Datum textrecv(PG_FUNCTION_ARGS)
Datum byteaGetBit(PG_FUNCTION_ARGS)
static void text_format_append_string(StringInfo buf, const char *str, int flags, int width)
static int text_position(text *t1, text *t2, Oid collid)
bool SplitDirectoriesString(char *rawstring, char separator, List **namelist)
Datum bytea_bit_count(PG_FUNCTION_ARGS)
Datum unicode_normalize_func(PG_FUNCTION_ARGS)
Datum bttext_pattern_sortsupport(PG_FUNCTION_ARGS)
static void split_text_accum_result(SplitTextOutputData *tstate, text *field_value, text *null_string, Oid collation)
Datum byteaSetBit(PG_FUNCTION_ARGS)
Datum split_part(PG_FUNCTION_ARGS)
Datum texteqname(PG_FUNCTION_ARGS)
static FmgrInfo * build_concat_foutcache(FunctionCallInfo fcinfo, int argidx)
Datum text_substr_no_len(PG_FUNCTION_ARGS)
Datum text_name(PG_FUNCTION_ARGS)
Datum byteaSetByte(PG_FUNCTION_ARGS)
Datum text_le(PG_FUNCTION_ARGS)
static void text_position_reset(TextPositionState *state)
Datum text_to_table(PG_FUNCTION_ARGS)
#define ADVANCE_PARSE_POINTER(ptr, end_ptr)
Datum textnename(PG_FUNCTION_ARGS)
static char * text_position_next_internal(char *start_ptr, TextPositionState *state)
Datum to_hex64(PG_FUNCTION_ARGS)
Datum text_to_array(PG_FUNCTION_ARGS)
Datum bytea_substr_no_len(PG_FUNCTION_ARGS)
Datum unicode_is_normalized(PG_FUNCTION_ARGS)
#define TEXT_FORMAT_FLAG_MINUS
static void check_collation_set(Oid collid)
bool SplitGUCList(char *rawstring, char separator, List **namelist)
char * text_to_cstring(const text *t)
Datum textoverlay(PG_FUNCTION_ARGS)
static void appendStringInfoRegexpSubstr(StringInfo str, text *replace_text, regmatch_t *pmatch, char *start_ptr, int data_pos)
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
static text * array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
Datum to_hex32(PG_FUNCTION_ARGS)
Datum text_starts_with(PG_FUNCTION_ARGS)
Datum byteale(PG_FUNCTION_ARGS)
Datum text_gt(PG_FUNCTION_ARGS)
Datum text_reverse(PG_FUNCTION_ARGS)
Datum to_bin64(PG_FUNCTION_ARGS)
Datum texteq(PG_FUNCTION_ARGS)
Datum to_oct64(PG_FUNCTION_ARGS)
Datum text_pattern_gt(PG_FUNCTION_ARGS)
static int charlen_to_bytelen(const char *p, int n)
void varstr_sortsupport(SortSupport ssup, Oid typid, Oid collid)
static int namefastcmp_c(Datum x, Datum y, SortSupport ssup)
#define PG_STR_GET_BYTEA(str_)
static StringInfo makeStringAggState(FunctionCallInfo fcinfo)
Datum textlename(PG_FUNCTION_ARGS)
Datum icu_unicode_version(PG_FUNCTION_ARGS)
static int namefastcmp_locale(Datum x, Datum y, SortSupport ssup)
Datum bytearecv(PG_FUNCTION_ARGS)
static Datum varstr_abbrev_convert(Datum original, SortSupport ssup)
Datum text_concat(PG_FUNCTION_ARGS)
text * cstring_to_text_with_len(const char *s, int len)
Datum text_pattern_lt(PG_FUNCTION_ARGS)
Datum text_pattern_ge(PG_FUNCTION_ARGS)
Datum btvarstrequalimage(PG_FUNCTION_ARGS)
Datum nameletext(PG_FUNCTION_ARGS)
Datum namenetext(PG_FUNCTION_ARGS)
static int text_position_get_match_pos(TextPositionState *state)
void text_to_cstring_buffer(const text *src, char *dst, size_t dst_len)
Datum to_bin32(PG_FUNCTION_ARGS)
Datum bytea_sortsupport(PG_FUNCTION_ARGS)
static bytea * bytea_substring(Datum str, int S, int L, bool length_not_specified)
Datum to_oct32(PG_FUNCTION_ARGS)
Datum namegttext(PG_FUNCTION_ARGS)
Datum unicode_version(PG_FUNCTION_ARGS)
Datum namegetext(PG_FUNCTION_ARGS)
static UnicodeNormalizationForm unicode_norm_form_from_string(const char *formstr)
static bytea * bytea_catenate(bytea *t1, bytea *t2)
static bool text_position_next(TextPositionState *state)
Datum textoctetlen(PG_FUNCTION_ARGS)
Datum textltname(PG_FUNCTION_ARGS)
Datum byteaoverlay_no_len(PG_FUNCTION_ARGS)
static text * concat_internal(const char *sepstr, int argidx, FunctionCallInfo fcinfo)
text * replace_text_regexp(text *src_text, text *pattern_text, text *replace_text, int cflags, Oid collation, int search_start, int n)
text * cstring_to_text(const char *s)
Datum bttextsortsupport(PG_FUNCTION_ARGS)
Datum text_format_nv(PG_FUNCTION_ARGS)
Datum textpos(PG_FUNCTION_ARGS)
static int varstrfastcmp_c(Datum x, Datum y, SortSupport ssup)
Datum bttext_pattern_cmp(PG_FUNCTION_ARGS)
Datum string_agg_finalfn(PG_FUNCTION_ARGS)
Datum byteaoctetlen(PG_FUNCTION_ARGS)
Datum unistr(PG_FUNCTION_ARGS)
static unsigned int hexval(unsigned char c)
static bool text_format_parse_digits(const char **ptr, const char *end_ptr, int *value)
Datum unknownin(PG_FUNCTION_ARGS)
static bool isxdigits_n(const char *instr, size_t n)
Datum string_agg_deserialize(PG_FUNCTION_ARGS)
Datum byteaout(PG_FUNCTION_ARGS)
Datum namelttext(PG_FUNCTION_ARGS)
Datum pg_column_size(PG_FUNCTION_ARGS)
Datum byteain(PG_FUNCTION_ARGS)
#define DatumGetVarStringPP(X)
Datum pg_column_compression(PG_FUNCTION_ARGS)
Datum name_text(PG_FUNCTION_ARGS)
Datum bytea_string_agg_transfn(PG_FUNCTION_ARGS)
Datum nameeqtext(PG_FUNCTION_ARGS)
Datum bttextnamecmp(PG_FUNCTION_ARGS)
void initClosestMatch(ClosestMatchState *state, const char *source, int max_d)
Datum textin(PG_FUNCTION_ARGS)
Datum string_agg_combine(PG_FUNCTION_ARGS)
Datum byteaGetByte(PG_FUNCTION_ARGS)
Datum btnametextcmp(PG_FUNCTION_ARGS)
Datum unknownsend(PG_FUNCTION_ARGS)
Datum text_pattern_le(PG_FUNCTION_ARGS)
void updateClosestMatch(ClosestMatchState *state, const char *candidate)
Datum bttextcmp(PG_FUNCTION_ARGS)
Datum unknownout(PG_FUNCTION_ARGS)
Datum replace_text(PG_FUNCTION_ARGS)
Datum textgename(PG_FUNCTION_ARGS)
static bool split_text(FunctionCallInfo fcinfo, SplitTextOutputData *tstate)
Datum bytea_substr(PG_FUNCTION_ARGS)
Datum bytealt(PG_FUNCTION_ARGS)
Datum byteasend(PG_FUNCTION_ARGS)
Datum text_lt(PG_FUNCTION_ARGS)
int varstr_levenshtein_less_equal(const char *source, int slen, const char *target, int tlen, int ins_c, int del_c, int sub_c, int max_d, bool trusted)