PostgreSQL Source Code  git master
varlena.h File Reference
#include "nodes/pg_list.h"
#include "utils/sortsupport.h"
Include dependency graph for varlena.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

int varstr_cmp (const char *arg1, int len1, const char *arg2, int len2, Oid collid)
 
void varstr_sortsupport (SortSupport ssup, Oid typid, Oid collid)
 
int varstr_levenshtein (const char *source, int slen, const char *target, int tlen, int ins_c, int del_c, int sub_c, bool trusted)
 
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)
 
ListtextToQualifiedNameList (text *textval)
 
bool SplitIdentifierString (char *rawstring, char separator, List **namelist)
 
bool SplitDirectoriesString (char *rawstring, char separator, List **namelist)
 
bool SplitGUCList (char *rawstring, char separator, List **namelist)
 
textreplace_text_regexp (text *src_text, void *regexp, text *replace_text, bool glob)
 

Function Documentation

◆ replace_text_regexp()

text* replace_text_regexp ( text src_text,
void *  regexp,
text replace_text,
bool  glob 
)

Definition at line 4421 of file varlena.c.

References appendBinaryStringInfo(), appendStringInfoRegexpSubstr(), appendStringInfoText(), buf, charlen_to_bytelen(), CHECK_FOR_INTERRUPTS, check_replace_text_has_escape_char(), cstring_to_text_with_len(), StringInfoData::data, ereport, errcode(), errmsg(), ERROR, initStringInfo(), StringInfoData::len, palloc(), pfree(), pg_mb2wchar_with_len(), pg_regerror(), pg_regexec(), REG_NOMATCH, REG_OKAY, REGEXP_REPLACE_BACKREF_CNT, regmatch_t::rm_eo, regmatch_t::rm_so, VARDATA_ANY, VARSIZE_ANY, and VARSIZE_ANY_EXHDR.

Referenced by textregexreplace(), and textregexreplace_noopt().

4423 {
4424  text *ret_text;
4425  regex_t *re = (regex_t *) regexp;
4426  int src_text_len = VARSIZE_ANY_EXHDR(src_text);
4429  pg_wchar *data;
4430  size_t data_len;
4431  int search_start;
4432  int data_pos;
4433  char *start_ptr;
4434  bool have_escape;
4435 
4436  initStringInfo(&buf);
4437 
4438  /* Convert data string to wide characters. */
4439  data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
4440  data_len = pg_mb2wchar_with_len(VARDATA_ANY(src_text), data, src_text_len);
4441 
4442  /* Check whether replace_text has escape char. */
4443  have_escape = check_replace_text_has_escape_char(replace_text);
4444 
4445  /* start_ptr points to the data_pos'th character of src_text */
4446  start_ptr = (char *) VARDATA_ANY(src_text);
4447  data_pos = 0;
4448 
4449  search_start = 0;
4450  while (search_start <= data_len)
4451  {
4452  int regexec_result;
4453 
4455 
4456  regexec_result = pg_regexec(re,
4457  data,
4458  data_len,
4459  search_start,
4460  NULL, /* no details */
4462  pmatch,
4463  0);
4464 
4465  if (regexec_result == REG_NOMATCH)
4466  break;
4467 
4468  if (regexec_result != REG_OKAY)
4469  {
4470  char errMsg[100];
4471 
4473  pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
4474  ereport(ERROR,
4475  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
4476  errmsg("regular expression failed: %s", errMsg)));
4477  }
4478 
4479  /*
4480  * Copy the text to the left of the match position. Note we are given
4481  * character not byte indexes.
4482  */
4483  if (pmatch[0].rm_so - data_pos > 0)
4484  {
4485  int chunk_len;
4486 
4487  chunk_len = charlen_to_bytelen(start_ptr,
4488  pmatch[0].rm_so - data_pos);
4489  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
4490 
4491  /*
4492  * Advance start_ptr over that text, to avoid multiple rescans of
4493  * it if the replace_text contains multiple back-references.
4494  */
4495  start_ptr += chunk_len;
4496  data_pos = pmatch[0].rm_so;
4497  }
4498 
4499  /*
4500  * Copy the replace_text. Process back references when the
4501  * replace_text has escape characters.
4502  */
4503  if (have_escape)
4504  appendStringInfoRegexpSubstr(&buf, replace_text, pmatch,
4505  start_ptr, data_pos);
4506  else
4507  appendStringInfoText(&buf, replace_text);
4508 
4509  /* Advance start_ptr and data_pos over the matched text. */
4510  start_ptr += charlen_to_bytelen(start_ptr,
4511  pmatch[0].rm_eo - data_pos);
4512  data_pos = pmatch[0].rm_eo;
4513 
4514  /*
4515  * When global option is off, replace the first instance only.
4516  */
4517  if (!glob)
4518  break;
4519 
4520  /*
4521  * Advance search position. Normally we start the next search at the
4522  * end of the previous match; but if the match was of zero length, we
4523  * have to advance by one character, or we'd just find the same match
4524  * again.
4525  */
4526  search_start = data_pos;
4527  if (pmatch[0].rm_so == pmatch[0].rm_eo)
4528  search_start++;
4529  }
4530 
4531  /*
4532  * Copy the text to the right of the last match.
4533  */
4534  if (data_pos < data_len)
4535  {
4536  int chunk_len;
4537 
4538  chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
4539  appendBinaryStringInfo(&buf, start_ptr, chunk_len);
4540  }
4541 
4542  ret_text = cstring_to_text_with_len(buf.data, buf.len);
4543  pfree(buf.data);
4544  pfree(data);
4545 
4546  return ret_text;
4547 }
#define VARDATA_ANY(PTR)
Definition: postgres.h:348
regoff_t rm_so
Definition: regex.h:85
int errcode(int sqlerrcode)
Definition: elog.c:570
regoff_t rm_eo
Definition: regex.h:86
void pfree(void *pointer)
Definition: mcxt.c:1031
#define REG_OKAY
Definition: regex.h:137
#define ERROR
Definition: elog.h:43
static bool check_replace_text_has_escape_char(const text *replace_text)
Definition: varlena.c:4283
static int charlen_to_bytelen(const char *p, int n)
Definition: varlena.c:757
static void appendStringInfoText(StringInfo str, const text *t)
Definition: varlena.c:4194
static char * buf
Definition: pg_test_fsync.c:68
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:183
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
Definition: regerror.c:60
#define ereport(elevel, rest)
Definition: elog.h:141
unsigned int pg_wchar
Definition: mbprint.c:31
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
#define REGEXP_REPLACE_BACKREF_CNT
Definition: varlena.c:4410
#define VARSIZE_ANY(PTR)
Definition: postgres.h:335
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:715
static void appendStringInfoRegexpSubstr(StringInfo str, text *replace_text, regmatch_t *pmatch, char *start_ptr, int data_pos)
Definition: varlena.c:4316
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)
Definition: regexec.c:172
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:341
void * palloc(Size size)
Definition: mcxt.c:924
int errmsg(const char *fmt,...)
Definition: elog.c:784
#define REG_NOMATCH
Definition: regex.h:138
Definition: c.h:549
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
void appendBinaryStringInfo(StringInfo str, const char *data, int datalen)
Definition: stringinfo.c:214
Definition: regex.h:55

◆ SplitDirectoriesString()

bool SplitDirectoriesString ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3796 of file varlena.c.

References canonicalize_path(), lappend(), MAXPGPATH, memmove, NIL, pstrdup(), and scanner_isspace().

Referenced by load_libraries(), and PostmasterMain().

3798 {
3799  char *nextp = rawstring;
3800  bool done = false;
3801 
3802  *namelist = NIL;
3803 
3804  while (scanner_isspace(*nextp))
3805  nextp++; /* skip leading whitespace */
3806 
3807  if (*nextp == '\0')
3808  return true; /* allow empty string */
3809 
3810  /* At the top of the loop, we are at start of a new directory. */
3811  do
3812  {
3813  char *curname;
3814  char *endp;
3815 
3816  if (*nextp == '"')
3817  {
3818  /* Quoted name --- collapse quote-quote pairs */
3819  curname = nextp + 1;
3820  for (;;)
3821  {
3822  endp = strchr(nextp + 1, '"');
3823  if (endp == NULL)
3824  return false; /* mismatched quotes */
3825  if (endp[1] != '"')
3826  break; /* found end of quoted name */
3827  /* Collapse adjacent quotes into one quote, and look again */
3828  memmove(endp, endp + 1, strlen(endp));
3829  nextp = endp;
3830  }
3831  /* endp now points at the terminating quote */
3832  nextp = endp + 1;
3833  }
3834  else
3835  {
3836  /* Unquoted name --- extends to separator or end of string */
3837  curname = endp = nextp;
3838  while (*nextp && *nextp != separator)
3839  {
3840  /* trailing whitespace should not be included in name */
3841  if (!scanner_isspace(*nextp))
3842  endp = nextp + 1;
3843  nextp++;
3844  }
3845  if (curname == endp)
3846  return false; /* empty unquoted name not allowed */
3847  }
3848 
3849  while (scanner_isspace(*nextp))
3850  nextp++; /* skip trailing whitespace */
3851 
3852  if (*nextp == separator)
3853  {
3854  nextp++;
3855  while (scanner_isspace(*nextp))
3856  nextp++; /* skip leading whitespace for next */
3857  /* we expect another name, so done remains false */
3858  }
3859  else if (*nextp == '\0')
3860  done = true;
3861  else
3862  return false; /* invalid syntax */
3863 
3864  /* Now safe to overwrite separator with a null */
3865  *endp = '\0';
3866 
3867  /* Truncate path if it's overlength */
3868  if (strlen(curname) >= MAXPGPATH)
3869  curname[MAXPGPATH - 1] = '\0';
3870 
3871  /*
3872  * Finished isolating current name --- add it to list
3873  */
3874  curname = pstrdup(curname);
3875  canonicalize_path(curname);
3876  *namelist = lappend(*namelist, curname);
3877 
3878  /* Loop back if we didn't reach end of string */
3879  } while (!done);
3880 
3881  return true;
3882 }
#define NIL
Definition: pg_list.h:65
char * pstrdup(const char *in)
Definition: mcxt.c:1161
void canonicalize_path(char *path)
Definition: path.c:254
#define MAXPGPATH
#define memmove(d, s, c)
Definition: c.h:1224
List * lappend(List *list, void *datum)
Definition: list.c:321
bool scanner_isspace(char ch)
Definition: scansup.c:221

◆ SplitGUCList()

bool SplitGUCList ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3917 of file varlena.c.

References lappend(), memmove, NIL, and scanner_isspace().

Referenced by dumpFunc(), and pg_get_functiondef().

3919 {
3920  char *nextp = rawstring;
3921  bool done = false;
3922 
3923  *namelist = NIL;
3924 
3925  while (scanner_isspace(*nextp))
3926  nextp++; /* skip leading whitespace */
3927 
3928  if (*nextp == '\0')
3929  return true; /* allow empty string */
3930 
3931  /* At the top of the loop, we are at start of a new identifier. */
3932  do
3933  {
3934  char *curname;
3935  char *endp;
3936 
3937  if (*nextp == '"')
3938  {
3939  /* Quoted name --- collapse quote-quote pairs */
3940  curname = nextp + 1;
3941  for (;;)
3942  {
3943  endp = strchr(nextp + 1, '"');
3944  if (endp == NULL)
3945  return false; /* mismatched quotes */
3946  if (endp[1] != '"')
3947  break; /* found end of quoted name */
3948  /* Collapse adjacent quotes into one quote, and look again */
3949  memmove(endp, endp + 1, strlen(endp));
3950  nextp = endp;
3951  }
3952  /* endp now points at the terminating quote */
3953  nextp = endp + 1;
3954  }
3955  else
3956  {
3957  /* Unquoted name --- extends to separator or whitespace */
3958  curname = nextp;
3959  while (*nextp && *nextp != separator &&
3960  !scanner_isspace(*nextp))
3961  nextp++;
3962  endp = nextp;
3963  if (curname == nextp)
3964  return false; /* empty unquoted name not allowed */
3965  }
3966 
3967  while (scanner_isspace(*nextp))
3968  nextp++; /* skip trailing whitespace */
3969 
3970  if (*nextp == separator)
3971  {
3972  nextp++;
3973  while (scanner_isspace(*nextp))
3974  nextp++; /* skip leading whitespace for next */
3975  /* we expect another name, so done remains false */
3976  }
3977  else if (*nextp == '\0')
3978  done = true;
3979  else
3980  return false; /* invalid syntax */
3981 
3982  /* Now safe to overwrite separator with a null */
3983  *endp = '\0';
3984 
3985  /*
3986  * Finished isolating current name --- add it to list
3987  */
3988  *namelist = lappend(*namelist, curname);
3989 
3990  /* Loop back if we didn't reach end of string */
3991  } while (!done);
3992 
3993  return true;
3994 }
#define NIL
Definition: pg_list.h:65
#define memmove(d, s, c)
Definition: c.h:1224
List * lappend(List *list, void *datum)
Definition: list.c:321
bool scanner_isspace(char ch)
Definition: scansup.c:221

◆ SplitIdentifierString()

bool SplitIdentifierString ( char *  rawstring,
char  separator,
List **  namelist 
)

Definition at line 3669 of file varlena.c.

References Assert, downcase_truncate_identifier(), lappend(), memmove, NIL, pfree(), scanner_isspace(), and truncate_identifier().

Referenced by check_datestyle(), check_log_destination(), check_search_path(), check_temp_tablespaces(), check_wal_consistency_checking(), ExtractExtensionList(), parse_extension_control_file(), parse_hba_auth_opt(), parse_output_parameters(), parse_publication_options(), plpgsql_extra_checks_check_hook(), PostmasterMain(), PrepareTempTablespaces(), recomputeNamespacePath(), stringToQualifiedNameList(), and textToQualifiedNameList().

3671 {
3672  char *nextp = rawstring;
3673  bool done = false;
3674 
3675  *namelist = NIL;
3676 
3677  while (scanner_isspace(*nextp))
3678  nextp++; /* skip leading whitespace */
3679 
3680  if (*nextp == '\0')
3681  return true; /* allow empty string */
3682 
3683  /* At the top of the loop, we are at start of a new identifier. */
3684  do
3685  {
3686  char *curname;
3687  char *endp;
3688 
3689  if (*nextp == '"')
3690  {
3691  /* Quoted name --- collapse quote-quote pairs, no downcasing */
3692  curname = nextp + 1;
3693  for (;;)
3694  {
3695  endp = strchr(nextp + 1, '"');
3696  if (endp == NULL)
3697  return false; /* mismatched quotes */
3698  if (endp[1] != '"')
3699  break; /* found end of quoted name */
3700  /* Collapse adjacent quotes into one quote, and look again */
3701  memmove(endp, endp + 1, strlen(endp));
3702  nextp = endp;
3703  }
3704  /* endp now points at the terminating quote */
3705  nextp = endp + 1;
3706  }
3707  else
3708  {
3709  /* Unquoted name --- extends to separator or whitespace */
3710  char *downname;
3711  int len;
3712 
3713  curname = nextp;
3714  while (*nextp && *nextp != separator &&
3715  !scanner_isspace(*nextp))
3716  nextp++;
3717  endp = nextp;
3718  if (curname == nextp)
3719  return false; /* empty unquoted name not allowed */
3720 
3721  /*
3722  * Downcase the identifier, using same code as main lexer does.
3723  *
3724  * XXX because we want to overwrite the input in-place, we cannot
3725  * support a downcasing transformation that increases the string
3726  * length. This is not a problem given the current implementation
3727  * of downcase_truncate_identifier, but we'll probably have to do
3728  * something about this someday.
3729  */
3730  len = endp - curname;
3731  downname = downcase_truncate_identifier(curname, len, false);
3732  Assert(strlen(downname) <= len);
3733  strncpy(curname, downname, len); /* strncpy is required here */
3734  pfree(downname);
3735  }
3736 
3737  while (scanner_isspace(*nextp))
3738  nextp++; /* skip trailing whitespace */
3739 
3740  if (*nextp == separator)
3741  {
3742  nextp++;
3743  while (scanner_isspace(*nextp))
3744  nextp++; /* skip leading whitespace for next */
3745  /* we expect another name, so done remains false */
3746  }
3747  else if (*nextp == '\0')
3748  done = true;
3749  else
3750  return false; /* invalid syntax */
3751 
3752  /* Now safe to overwrite separator with a null */
3753  *endp = '\0';
3754 
3755  /* Truncate name if it's overlength */
3756  truncate_identifier(curname, strlen(curname), false);
3757 
3758  /*
3759  * Finished isolating current name --- add it to list
3760  */
3761  *namelist = lappend(*namelist, curname);
3762 
3763  /* Loop back if we didn't reach end of string */
3764  } while (!done);
3765 
3766  return true;
3767 }
#define NIL
Definition: pg_list.h:65
char * downcase_truncate_identifier(const char *ident, int len, bool warn)
Definition: scansup.c:131
void truncate_identifier(char *ident, int len, bool warn)
Definition: scansup.c:187
void pfree(void *pointer)
Definition: mcxt.c:1031
#define memmove(d, s, c)
Definition: c.h:1224
List * lappend(List *list, void *datum)
Definition: list.c:321
bool scanner_isspace(char ch)
Definition: scansup.c:221
#define Assert(condition)
Definition: c.h:732

◆ textToQualifiedNameList()

List* textToQualifiedNameList ( text textval)

Definition at line 3611 of file varlena.c.

References ereport, errcode(), errmsg(), ERROR, lappend(), lfirst, list_free(), makeString(), NIL, pfree(), pstrdup(), SplitIdentifierString(), and text_to_cstring().

Referenced by bt_metap(), bt_page_items(), bt_page_stats(), convert_table_name(), currtid_byrelname(), get_raw_page_internal(), get_rel_from_relname(), nextval(), pg_get_serial_sequence(), pg_get_viewdef_name(), pg_get_viewdef_name_ext(), pg_relpages(), pg_relpages_v1_5(), pgrowlocks(), pgstatindex(), pgstatindex_v1_5(), pgstattuple(), pgstattuple_v1_5(), row_security_active_name(), text_regclass(), ts_parse_byname(), and ts_token_type_byname().

3612 {
3613  char *rawname;
3614  List *result = NIL;
3615  List *namelist;
3616  ListCell *l;
3617 
3618  /* Convert to C string (handles possible detoasting). */
3619  /* Note we rely on being able to modify rawname below. */
3620  rawname = text_to_cstring(textval);
3621 
3622  if (!SplitIdentifierString(rawname, '.', &namelist))
3623  ereport(ERROR,
3624  (errcode(ERRCODE_INVALID_NAME),
3625  errmsg("invalid name syntax")));
3626 
3627  if (namelist == NIL)
3628  ereport(ERROR,
3629  (errcode(ERRCODE_INVALID_NAME),
3630  errmsg("invalid name syntax")));
3631 
3632  foreach(l, namelist)
3633  {
3634  char *curname = (char *) lfirst(l);
3635 
3636  result = lappend(result, makeString(pstrdup(curname)));
3637  }
3638 
3639  pfree(rawname);
3640  list_free(namelist);
3641 
3642  return result;
3643 }
Value * makeString(char *str)
Definition: value.c:53
#define NIL
Definition: pg_list.h:65
char * pstrdup(const char *in)
Definition: mcxt.c:1161
int errcode(int sqlerrcode)
Definition: elog.c:570
void pfree(void *pointer)
Definition: mcxt.c:1031
#define ERROR
Definition: elog.h:43
bool SplitIdentifierString(char *rawstring, char separator, List **namelist)
Definition: varlena.c:3669
#define ereport(elevel, rest)
Definition: elog.h:141
List * lappend(List *list, void *datum)
Definition: list.c:321
#define lfirst(lc)
Definition: pg_list.h:190
char * text_to_cstring(const text *t)
Definition: varlena.c:204
int errmsg(const char *fmt,...)
Definition: elog.c:784
void list_free(List *list)
Definition: list.c:1330
Definition: pg_list.h:50

◆ varstr_cmp()

int varstr_cmp ( const char *  arg1,
int  len1,
const char *  arg2,
int  len2,
Oid  collid 
)

Definition at line 1468 of file varlena.c.

References check_collation_set(), pg_locale_struct::deterministic, elog, ereport, errmsg(), ERROR, GetDatabaseEncoding(), pg_locale_struct::info, lc_collate_is_c(), Min, palloc(), pfree(), pg_newlocale_from_collation(), PG_UTF8, pg_locale_struct::provider, status(), strcoll_l, TEXTBUFLEN, and wcscoll_l.

Referenced by bpchar_larger(), bpchar_smaller(), bpcharcmp(), bpchareq(), bpcharge(), bpchargt(), bpcharle(), bpcharlt(), bpcharne(), btnametextcmp(), bttextnamecmp(), citextcmp(), compareItems(), compareJsonbScalarValue(), gin_compare_jsonb(), make_greater_string(), namecmp(), nameeqtext(), namenetext(), spg_text_leaf_consistent(), text_cmp(), texteqname(), and textnename().

1469 {
1470  int result;
1471 
1472  check_collation_set(collid);
1473 
1474  /*
1475  * Unfortunately, there is no strncoll(), so in the non-C locale case we
1476  * have to do some memory copying. This turns out to be significantly
1477  * slower, so we optimize the case where LC_COLLATE is C. We also try to
1478  * optimize relatively-short strings by avoiding palloc/pfree overhead.
1479  */
1480  if (lc_collate_is_c(collid))
1481  {
1482  result = memcmp(arg1, arg2, Min(len1, len2));
1483  if ((result == 0) && (len1 != len2))
1484  result = (len1 < len2) ? -1 : 1;
1485  }
1486  else
1487  {
1488  char a1buf[TEXTBUFLEN];
1489  char a2buf[TEXTBUFLEN];
1490  char *a1p,
1491  *a2p;
1492  pg_locale_t mylocale = 0;
1493 
1494  if (collid != DEFAULT_COLLATION_OID)
1495  mylocale = pg_newlocale_from_collation(collid);
1496 
1497  /*
1498  * memcmp() can't tell us which of two unequal strings sorts first,
1499  * but it's a cheap way to tell if they're equal. Testing shows that
1500  * memcmp() followed by strcoll() is only trivially slower than
1501  * strcoll() by itself, so we don't lose much if this doesn't work out
1502  * very often, and if it does - for example, because there are many
1503  * equal strings in the input - then we win big by avoiding expensive
1504  * collation-aware comparisons.
1505  */
1506  if (len1 == len2 && memcmp(arg1, arg2, len1) == 0)
1507  return 0;
1508 
1509 #ifdef WIN32
1510  /* Win32 does not have UTF-8, so we need to map to UTF-16 */
1511  if (GetDatabaseEncoding() == PG_UTF8
1512  && (!mylocale || mylocale->provider == COLLPROVIDER_LIBC))
1513  {
1514  int a1len;
1515  int a2len;
1516  int r;
1517 
1518  if (len1 >= TEXTBUFLEN / 2)
1519  {
1520  a1len = len1 * 2 + 2;
1521  a1p = palloc(a1len);
1522  }
1523  else
1524  {
1525  a1len = TEXTBUFLEN;
1526  a1p = a1buf;
1527  }
1528  if (len2 >= TEXTBUFLEN / 2)
1529  {
1530  a2len = len2 * 2 + 2;
1531  a2p = palloc(a2len);
1532  }
1533  else
1534  {
1535  a2len = TEXTBUFLEN;
1536  a2p = a2buf;
1537  }
1538 
1539  /* stupid Microsloth API does not work for zero-length input */
1540  if (len1 == 0)
1541  r = 0;
1542  else
1543  {
1544  r = MultiByteToWideChar(CP_UTF8, 0, arg1, len1,
1545  (LPWSTR) a1p, a1len / 2);
1546  if (!r)
1547  ereport(ERROR,
1548  (errmsg("could not convert string to UTF-16: error code %lu",
1549  GetLastError())));
1550  }
1551  ((LPWSTR) a1p)[r] = 0;
1552 
1553  if (len2 == 0)
1554  r = 0;
1555  else
1556  {
1557  r = MultiByteToWideChar(CP_UTF8, 0, arg2, len2,
1558  (LPWSTR) a2p, a2len / 2);
1559  if (!r)
1560  ereport(ERROR,
1561  (errmsg("could not convert string to UTF-16: error code %lu",
1562  GetLastError())));
1563  }
1564  ((LPWSTR) a2p)[r] = 0;
1565 
1566  errno = 0;
1567 #ifdef HAVE_LOCALE_T
1568  if (mylocale)
1569  result = wcscoll_l((LPWSTR) a1p, (LPWSTR) a2p, mylocale->info.lt);
1570  else
1571 #endif
1572  result = wcscoll((LPWSTR) a1p, (LPWSTR) a2p);
1573  if (result == 2147483647) /* _NLSCMPERROR; missing from mingw
1574  * headers */
1575  ereport(ERROR,
1576  (errmsg("could not compare Unicode strings: %m")));
1577 
1578  /* Break tie if necessary. */
1579  if (result == 0 &&
1580  (!mylocale || mylocale->deterministic))
1581  {
1582  result = memcmp(arg1, arg2, Min(len1, len2));
1583  if ((result == 0) && (len1 != len2))
1584  result = (len1 < len2) ? -1 : 1;
1585  }
1586 
1587  if (a1p != a1buf)
1588  pfree(a1p);
1589  if (a2p != a2buf)
1590  pfree(a2p);
1591 
1592  return result;
1593  }
1594 #endif /* WIN32 */
1595 
1596  if (len1 >= TEXTBUFLEN)
1597  a1p = (char *) palloc(len1 + 1);
1598  else
1599  a1p = a1buf;
1600  if (len2 >= TEXTBUFLEN)
1601  a2p = (char *) palloc(len2 + 1);
1602  else
1603  a2p = a2buf;
1604 
1605  memcpy(a1p, arg1, len1);
1606  a1p[len1] = '\0';
1607  memcpy(a2p, arg2, len2);
1608  a2p[len2] = '\0';
1609 
1610  if (mylocale)
1611  {
1612  if (mylocale->provider == COLLPROVIDER_ICU)
1613  {
1614 #ifdef USE_ICU
1615 #ifdef HAVE_UCOL_STRCOLLUTF8
1616  if (GetDatabaseEncoding() == PG_UTF8)
1617  {
1618  UErrorCode status;
1619 
1620  status = U_ZERO_ERROR;
1621  result = ucol_strcollUTF8(mylocale->info.icu.ucol,
1622  arg1, len1,
1623  arg2, len2,
1624  &status);
1625  if (U_FAILURE(status))
1626  ereport(ERROR,
1627  (errmsg("collation failed: %s", u_errorName(status))));
1628  }
1629  else
1630 #endif
1631  {
1632  int32_t ulen1,
1633  ulen2;
1634  UChar *uchar1,
1635  *uchar2;
1636 
1637  ulen1 = icu_to_uchar(&uchar1, arg1, len1);
1638  ulen2 = icu_to_uchar(&uchar2, arg2, len2);
1639 
1640  result = ucol_strcoll(mylocale->info.icu.ucol,
1641  uchar1, ulen1,
1642  uchar2, ulen2);
1643 
1644  pfree(uchar1);
1645  pfree(uchar2);
1646  }
1647 #else /* not USE_ICU */
1648  /* shouldn't happen */
1649  elog(ERROR, "unsupported collprovider: %c", mylocale->provider);
1650 #endif /* not USE_ICU */
1651  }
1652  else
1653  {
1654 #ifdef HAVE_LOCALE_T
1655  result = strcoll_l(a1p, a2p, mylocale->info.lt);
1656 #else
1657  /* shouldn't happen */
1658  elog(ERROR, "unsupported collprovider: %c", mylocale->provider);
1659 #endif
1660  }
1661  }
1662  else
1663  result = strcoll(a1p, a2p);
1664 
1665  /* Break tie if necessary. */
1666  if (result == 0 &&
1667  (!mylocale || mylocale->deterministic))
1668  result = strcmp(a1p, a2p);
1669 
1670  if (a1p != a1buf)
1671  pfree(a1p);
1672  if (a2p != a2buf)
1673  pfree(a2p);
1674  }
1675 
1676  return result;
1677 }
#define Min(x, y)
Definition: c.h:890
void pfree(void *pointer)
Definition: mcxt.c:1031
#define ERROR
Definition: elog.h:43
bool lc_collate_is_c(Oid collation)
Definition: pg_locale.c:1191
static void check_collation_set(Oid collid)
Definition: varlena.c:1445
#define strcoll_l
Definition: win32_port.h:395
#define ereport(elevel, rest)
Definition: elog.h:141
pg_locale_t pg_newlocale_from_collation(Oid collid)
Definition: pg_locale.c:1338
int GetDatabaseEncoding(void)
Definition: mbutils.c:996
bool deterministic
Definition: pg_locale.h:85
#define wcscoll_l
Definition: win32_port.h:397
#define TEXTBUFLEN
Definition: varlena.c:98
void * palloc(Size size)
Definition: mcxt.c:924
int errmsg(const char *fmt,...)
Definition: elog.c:784
#define elog(elevel,...)
Definition: elog.h:226
int int32_t
Definition: crypt.c:108
union pg_locale_struct::@143 info
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:227

◆ varstr_levenshtein()

int varstr_levenshtein ( const char *  source,
int  slen,
const char *  target,
int  tlen,
int  ins_c,
int  del_c,
int  sub_c,
bool  trusted 
)

Definition at line 73 of file levenshtein.c.

References ereport, errcode(), errmsg(), ERROR, i, MAX_LEVENSHTEIN_STRLEN, Min, palloc(), pg_mblen(), pg_mbstrlen_with_len(), rest_of_char_same(), START_COLUMN, and STOP_COLUMN.

Referenced by levenshtein(), and levenshtein_with_costs().

78 {
79  int m,
80  n;
81  int *prev;
82  int *curr;
83  int *s_char_len = NULL;
84  int i,
85  j;
86  const char *y;
87 
88  /*
89  * For varstr_levenshtein_less_equal, we have real variables called
90  * start_column and stop_column; otherwise it's just short-hand for 0 and
91  * m.
92  */
93 #ifdef LEVENSHTEIN_LESS_EQUAL
94  int start_column,
95  stop_column;
96 
97 #undef START_COLUMN
98 #undef STOP_COLUMN
99 #define START_COLUMN start_column
100 #define STOP_COLUMN stop_column
101 #else
102 #undef START_COLUMN
103 #undef STOP_COLUMN
104 #define START_COLUMN 0
105 #define STOP_COLUMN m
106 #endif
107 
108  /* Convert string lengths (in bytes) to lengths in characters */
109  m = pg_mbstrlen_with_len(source, slen);
110  n = pg_mbstrlen_with_len(target, tlen);
111 
112  /*
113  * We can transform an empty s into t with n insertions, or a non-empty t
114  * into an empty s with m deletions.
115  */
116  if (!m)
117  return n * ins_c;
118  if (!n)
119  return m * del_c;
120 
121  /*
122  * For security concerns, restrict excessive CPU+RAM usage. (This
123  * implementation uses O(m) memory and has O(mn) complexity.) If
124  * "trusted" is true, caller is responsible for not making excessive
125  * requests, typically by using a small max_d along with strings that are
126  * bounded, though not necessarily to MAX_LEVENSHTEIN_STRLEN exactly.
127  */
128  if (!trusted &&
129  (m > MAX_LEVENSHTEIN_STRLEN ||
131  ereport(ERROR,
132  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
133  errmsg("levenshtein argument exceeds maximum length of %d characters",
135 
136 #ifdef LEVENSHTEIN_LESS_EQUAL
137  /* Initialize start and stop columns. */
138  start_column = 0;
139  stop_column = m + 1;
140 
141  /*
142  * If max_d >= 0, determine whether the bound is impossibly tight. If so,
143  * return max_d + 1 immediately. Otherwise, determine whether it's tight
144  * enough to limit the computation we must perform. If so, figure out
145  * initial stop column.
146  */
147  if (max_d >= 0)
148  {
149  int min_theo_d; /* Theoretical minimum distance. */
150  int max_theo_d; /* Theoretical maximum distance. */
151  int net_inserts = n - m;
152 
153  min_theo_d = net_inserts < 0 ?
154  -net_inserts * del_c : net_inserts * ins_c;
155  if (min_theo_d > max_d)
156  return max_d + 1;
157  if (ins_c + del_c < sub_c)
158  sub_c = ins_c + del_c;
159  max_theo_d = min_theo_d + sub_c * Min(m, n);
160  if (max_d >= max_theo_d)
161  max_d = -1;
162  else if (ins_c + del_c > 0)
163  {
164  /*
165  * Figure out how much of the first row of the notional matrix we
166  * need to fill in. If the string is growing, the theoretical
167  * minimum distance already incorporates the cost of deleting the
168  * number of characters necessary to make the two strings equal in
169  * length. Each additional deletion forces another insertion, so
170  * the best-case total cost increases by ins_c + del_c. If the
171  * string is shrinking, the minimum theoretical cost assumes no
172  * excess deletions; that is, we're starting no further right than
173  * column n - m. If we do start further right, the best-case
174  * total cost increases by ins_c + del_c for each move right.
175  */
176  int slack_d = max_d - min_theo_d;
177  int best_column = net_inserts < 0 ? -net_inserts : 0;
178 
179  stop_column = best_column + (slack_d / (ins_c + del_c)) + 1;
180  if (stop_column > m)
181  stop_column = m + 1;
182  }
183  }
184 #endif
185 
186  /*
187  * In order to avoid calling pg_mblen() repeatedly on each character in s,
188  * we cache all the lengths before starting the main loop -- but if all
189  * the characters in both strings are single byte, then we skip this and
190  * use a fast-path in the main loop. If only one string contains
191  * multi-byte characters, we still build the array, so that the fast-path
192  * needn't deal with the case where the array hasn't been initialized.
193  */
194  if (m != slen || n != tlen)
195  {
196  int i;
197  const char *cp = source;
198 
199  s_char_len = (int *) palloc((m + 1) * sizeof(int));
200  for (i = 0; i < m; ++i)
201  {
202  s_char_len[i] = pg_mblen(cp);
203  cp += s_char_len[i];
204  }
205  s_char_len[i] = 0;
206  }
207 
208  /* One more cell for initialization column and row. */
209  ++m;
210  ++n;
211 
212  /* Previous and current rows of notional array. */
213  prev = (int *) palloc(2 * m * sizeof(int));
214  curr = prev + m;
215 
216  /*
217  * To transform the first i characters of s into the first 0 characters of
218  * t, we must perform i deletions.
219  */
220  for (i = START_COLUMN; i < STOP_COLUMN; i++)
221  prev[i] = i * del_c;
222 
223  /* Loop through rows of the notional array */
224  for (y = target, j = 1; j < n; j++)
225  {
226  int *temp;
227  const char *x = source;
228  int y_char_len = n != tlen + 1 ? pg_mblen(y) : 1;
229 
230 #ifdef LEVENSHTEIN_LESS_EQUAL
231 
232  /*
233  * In the best case, values percolate down the diagonal unchanged, so
234  * we must increment stop_column unless it's already on the right end
235  * of the array. The inner loop will read prev[stop_column], so we
236  * have to initialize it even though it shouldn't affect the result.
237  */
238  if (stop_column < m)
239  {
240  prev[stop_column] = max_d + 1;
241  ++stop_column;
242  }
243 
244  /*
245  * The main loop fills in curr, but curr[0] needs a special case: to
246  * transform the first 0 characters of s into the first j characters
247  * of t, we must perform j insertions. However, if start_column > 0,
248  * this special case does not apply.
249  */
250  if (start_column == 0)
251  {
252  curr[0] = j * ins_c;
253  i = 1;
254  }
255  else
256  i = start_column;
257 #else
258  curr[0] = j * ins_c;
259  i = 1;
260 #endif
261 
262  /*
263  * This inner loop is critical to performance, so we include a
264  * fast-path to handle the (fairly common) case where no multibyte
265  * characters are in the mix. The fast-path is entitled to assume
266  * that if s_char_len is not initialized then BOTH strings contain
267  * only single-byte characters.
268  */
269  if (s_char_len != NULL)
270  {
271  for (; i < STOP_COLUMN; i++)
272  {
273  int ins;
274  int del;
275  int sub;
276  int x_char_len = s_char_len[i - 1];
277 
278  /*
279  * Calculate costs for insertion, deletion, and substitution.
280  *
281  * When calculating cost for substitution, we compare the last
282  * character of each possibly-multibyte character first,
283  * because that's enough to rule out most mis-matches. If we
284  * get past that test, then we compare the lengths and the
285  * remaining bytes.
286  */
287  ins = prev[i] + ins_c;
288  del = curr[i - 1] + del_c;
289  if (x[x_char_len - 1] == y[y_char_len - 1]
290  && x_char_len == y_char_len &&
291  (x_char_len == 1 || rest_of_char_same(x, y, x_char_len)))
292  sub = prev[i - 1];
293  else
294  sub = prev[i - 1] + sub_c;
295 
296  /* Take the one with minimum cost. */
297  curr[i] = Min(ins, del);
298  curr[i] = Min(curr[i], sub);
299 
300  /* Point to next character. */
301  x += x_char_len;
302  }
303  }
304  else
305  {
306  for (; i < STOP_COLUMN; i++)
307  {
308  int ins;
309  int del;
310  int sub;
311 
312  /* Calculate costs for insertion, deletion, and substitution. */
313  ins = prev[i] + ins_c;
314  del = curr[i - 1] + del_c;
315  sub = prev[i - 1] + ((*x == *y) ? 0 : sub_c);
316 
317  /* Take the one with minimum cost. */
318  curr[i] = Min(ins, del);
319  curr[i] = Min(curr[i], sub);
320 
321  /* Point to next character. */
322  x++;
323  }
324  }
325 
326  /* Swap current row with previous row. */
327  temp = curr;
328  curr = prev;
329  prev = temp;
330 
331  /* Point to next character. */
332  y += y_char_len;
333 
334 #ifdef LEVENSHTEIN_LESS_EQUAL
335 
336  /*
337  * This chunk of code represents a significant performance hit if used
338  * in the case where there is no max_d bound. This is probably not
339  * because the max_d >= 0 test itself is expensive, but rather because
340  * the possibility of needing to execute this code prevents tight
341  * optimization of the loop as a whole.
342  */
343  if (max_d >= 0)
344  {
345  /*
346  * The "zero point" is the column of the current row where the
347  * remaining portions of the strings are of equal length. There
348  * are (n - 1) characters in the target string, of which j have
349  * been transformed. There are (m - 1) characters in the source
350  * string, so we want to find the value for zp where (n - 1) - j =
351  * (m - 1) - zp.
352  */
353  int zp = j - (n - m);
354 
355  /* Check whether the stop column can slide left. */
356  while (stop_column > 0)
357  {
358  int ii = stop_column - 1;
359  int net_inserts = ii - zp;
360 
361  if (prev[ii] + (net_inserts > 0 ? net_inserts * ins_c :
362  -net_inserts * del_c) <= max_d)
363  break;
364  stop_column--;
365  }
366 
367  /* Check whether the start column can slide right. */
368  while (start_column < stop_column)
369  {
370  int net_inserts = start_column - zp;
371 
372  if (prev[start_column] +
373  (net_inserts > 0 ? net_inserts * ins_c :
374  -net_inserts * del_c) <= max_d)
375  break;
376 
377  /*
378  * We'll never again update these values, so we must make sure
379  * there's nothing here that could confuse any future
380  * iteration of the outer loop.
381  */
382  prev[start_column] = max_d + 1;
383  curr[start_column] = max_d + 1;
384  if (start_column != 0)
385  source += (s_char_len != NULL) ? s_char_len[start_column - 1] : 1;
386  start_column++;
387  }
388 
389  /* If they cross, we're going to exceed the bound. */
390  if (start_column >= stop_column)
391  return max_d + 1;
392  }
393 #endif
394  }
395 
396  /*
397  * Because the final value was swapped from the previous row to the
398  * current row, that's where we'll find it.
399  */
400  return prev[m - 1];
401 }
#define Min(x, y)
Definition: c.h:890
int errcode(int sqlerrcode)
Definition: elog.c:570
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:786
#define STOP_COLUMN
#define ERROR
Definition: elog.h:43
#define START_COLUMN
#define ereport(elevel, rest)
Definition: elog.h:141
#define MAX_LEVENSHTEIN_STRLEN
Definition: levenshtein.c:26
static bool rest_of_char_same(const char *s1, const char *s2, int len)
Definition: varlena.c:5961
int pg_mblen(const char *mbstr)
Definition: mbutils.c:752
void * palloc(Size size)
Definition: mcxt.c:924
int errmsg(const char *fmt,...)
Definition: elog.c:784
int i

◆ varstr_levenshtein_less_equal()

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 
)

◆ varstr_sortsupport()

void varstr_sortsupport ( SortSupport  ssup,
Oid  typid,
Oid  collid 
)

Definition at line 1953 of file varlena.c.

References VarStringSortSupport::abbr_card, SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, bpcharfastcmp_c(), VarStringSortSupport::buf1, VarStringSortSupport::buf2, VarStringSortSupport::buflen1, VarStringSortSupport::buflen2, VarStringSortSupport::cache_blob, check_collation_set(), VarStringSortSupport::collate_c, SortSupportData::comparator, VarStringSortSupport::full_card, GetDatabaseEncoding(), initHyperLogLog(), VarStringSortSupport::last_len1, VarStringSortSupport::last_len2, VarStringSortSupport::last_returned, lc_collate_is_c(), VarStringSortSupport::locale, locale, namefastcmp_c(), namefastcmp_locale(), palloc(), pg_newlocale_from_collation(), PG_UTF8, VarStringSortSupport::prop_card, pg_locale_struct::provider, SortSupportData::ssup_extra, TEXTBUFLEN, VarStringSortSupport::typid, varlenafastcmp_locale(), varstr_abbrev_abort(), varstr_abbrev_convert(), varstrcmp_abbrev(), and varstrfastcmp_c().

Referenced by bpchar_sortsupport(), btbpchar_pattern_sortsupport(), btnamesortsupport(), bttext_pattern_sortsupport(), bttextsortsupport(), and bytea_sortsupport().

1954 {
1955  bool abbreviate = ssup->abbreviate;
1956  bool collate_c = false;
1957  VarStringSortSupport *sss;
1958  pg_locale_t locale = 0;
1959 
1960  check_collation_set(collid);
1961 
1962  /*
1963  * If possible, set ssup->comparator to a function which can be used to
1964  * directly compare two datums. If we can do this, we'll avoid the
1965  * overhead of a trip through the fmgr layer for every comparison, which
1966  * can be substantial.
1967  *
1968  * Most typically, we'll set the comparator to varlenafastcmp_locale,
1969  * which uses strcoll() to perform comparisons. We use that for the
1970  * BpChar case too, but type NAME uses namefastcmp_locale. However, if
1971  * LC_COLLATE = C, we can make things quite a bit faster with
1972  * varstrfastcmp_c, bpcharfastcmp_c, or namefastcmp_c, all of which use
1973  * memcmp() rather than strcoll().
1974  */
1975  if (lc_collate_is_c(collid))
1976  {
1977  if (typid == BPCHAROID)
1978  ssup->comparator = bpcharfastcmp_c;
1979  else if (typid == NAMEOID)
1980  {
1981  ssup->comparator = namefastcmp_c;
1982  /* Not supporting abbreviation with type NAME, for now */
1983  abbreviate = false;
1984  }
1985  else
1986  ssup->comparator = varstrfastcmp_c;
1987 
1988  collate_c = true;
1989  }
1990  else
1991  {
1992  /*
1993  * We need a collation-sensitive comparison. To make things faster,
1994  * we'll figure out the collation based on the locale id and cache the
1995  * result.
1996  */
1997  if (collid != DEFAULT_COLLATION_OID)
1998  locale = pg_newlocale_from_collation(collid);
1999 
2000  /*
2001  * There is a further exception on Windows. When the database
2002  * encoding is UTF-8 and we are not using the C collation, complex
2003  * hacks are required. We don't currently have a comparator that
2004  * handles that case, so we fall back on the slow method of having the
2005  * sort code invoke bttextcmp() (in the case of text) via the fmgr
2006  * trampoline. ICU locales work just the same on Windows, however.
2007  */
2008 #ifdef WIN32
2009  if (GetDatabaseEncoding() == PG_UTF8 &&
2010  !(locale && locale->provider == COLLPROVIDER_ICU))
2011  return;
2012 #endif
2013 
2014  /*
2015  * We use varlenafastcmp_locale except for type NAME.
2016  */
2017  if (typid == NAMEOID)
2018  {
2020  /* Not supporting abbreviation with type NAME, for now */
2021  abbreviate = false;
2022  }
2023  else
2025  }
2026 
2027  /*
2028  * Unfortunately, it seems that abbreviation for non-C collations is
2029  * broken on many common platforms; testing of multiple versions of glibc
2030  * reveals that, for many locales, strcoll() and strxfrm() do not return
2031  * consistent results, which is fatal to this optimization. While no
2032  * other libc other than Cygwin has so far been shown to have a problem,
2033  * we take the conservative course of action for right now and disable
2034  * this categorically. (Users who are certain this isn't a problem on
2035  * their system can define TRUST_STRXFRM.)
2036  *
2037  * Even apart from the risk of broken locales, it's possible that there
2038  * are platforms where the use of abbreviated keys should be disabled at
2039  * compile time. Having only 4 byte datums could make worst-case
2040  * performance drastically more likely, for example. Moreover, macOS's
2041  * strxfrm() implementation is known to not effectively concentrate a
2042  * significant amount of entropy from the original string in earlier
2043  * transformed blobs. It's possible that other supported platforms are
2044  * similarly encumbered. So, if we ever get past disabling this
2045  * categorically, we may still want or need to disable it for particular
2046  * platforms.
2047  */
2048 #ifndef TRUST_STRXFRM
2049  if (!collate_c && !(locale && locale->provider == COLLPROVIDER_ICU))
2050  abbreviate = false;
2051 #endif
2052 
2053  /*
2054  * If we're using abbreviated keys, or if we're using a locale-aware
2055  * comparison, we need to initialize a StringSortSupport object. Both
2056  * cases will make use of the temporary buffers we initialize here for
2057  * scratch space (and to detect requirement for BpChar semantics from
2058  * caller), and the abbreviation case requires additional state.
2059  */
2060  if (abbreviate || !collate_c)
2061  {
2062  sss = palloc(sizeof(VarStringSortSupport));
2063  sss->buf1 = palloc(TEXTBUFLEN);
2064  sss->buflen1 = TEXTBUFLEN;
2065  sss->buf2 = palloc(TEXTBUFLEN);
2066  sss->buflen2 = TEXTBUFLEN;
2067  /* Start with invalid values */
2068  sss->last_len1 = -1;
2069  sss->last_len2 = -1;
2070  /* Initialize */
2071  sss->last_returned = 0;
2072  sss->locale = locale;
2073 
2074  /*
2075  * To avoid somehow confusing a strxfrm() blob and an original string,
2076  * constantly keep track of the variety of data that buf1 and buf2
2077  * currently contain.
2078  *
2079  * Comparisons may be interleaved with conversion calls. Frequently,
2080  * conversions and comparisons are batched into two distinct phases,
2081  * but the correctness of caching cannot hinge upon this. For
2082  * comparison caching, buffer state is only trusted if cache_blob is
2083  * found set to false, whereas strxfrm() caching only trusts the state
2084  * when cache_blob is found set to true.
2085  *
2086  * Arbitrarily initialize cache_blob to true.
2087  */
2088  sss->cache_blob = true;
2089  sss->collate_c = collate_c;
2090  sss->typid = typid;
2091  ssup->ssup_extra = sss;
2092 
2093  /*
2094  * If possible, plan to use the abbreviated keys optimization. The
2095  * core code may switch back to authoritative comparator should
2096  * abbreviation be aborted.
2097  */
2098  if (abbreviate)
2099  {
2100  sss->prop_card = 0.20;
2101  initHyperLogLog(&sss->abbr_card, 10);
2102  initHyperLogLog(&sss->full_card, 10);
2103  ssup->abbrev_full_comparator = ssup->comparator;
2104  ssup->comparator = varstrcmp_abbrev;
2107  }
2108  }
2109 }
static int bpcharfastcmp_c(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2152
static Datum varstr_abbrev_convert(Datum original, SortSupport ssup)
Definition: varlena.c:2419
static int varstrcmp_abbrev(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2394
static int varstrfastcmp_c(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2115
static int varlenafastcmp_locale(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2197
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
Definition: hyperloglog.c:65
bool lc_collate_is_c(Oid collation)
Definition: pg_locale.c:1191
static void check_collation_set(Oid collid)
Definition: varlena.c:1445
static int namefastcmp_locale(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2228
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:106
hyperLogLogState abbr_card
Definition: varlena.c:88
pg_locale_t locale
Definition: varlena.c:91
int(* abbrev_full_comparator)(Datum x, Datum y, SortSupport ssup)
Definition: sortsupport.h:191
Datum(* abbrev_converter)(Datum original, SortSupport ssup)
Definition: sortsupport.h:172
void * ssup_extra
Definition: sortsupport.h:87
pg_locale_t pg_newlocale_from_collation(Oid collid)
Definition: pg_locale.c:1338
int GetDatabaseEncoding(void)
Definition: mbutils.c:996
hyperLogLogState full_card
Definition: varlena.c:89
bool(* abbrev_abort)(int memtupcount, SortSupport ssup)
Definition: sortsupport.h:182
static bool varstr_abbrev_abort(int memtupcount, SortSupport ssup)
Definition: varlena.c:2659
#define TEXTBUFLEN
Definition: varlena.c:98
void * palloc(Size size)
Definition: mcxt.c:924
static char * locale
Definition: initdb.c:125
static int namefastcmp_c(Datum x, Datum y, SortSupport ssup)
Definition: varlena.c:2185