PostgreSQL Source Code  git master
collationcmds.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * collationcmds.c
4  * collation-related commands support code
5  *
6  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/commands/collationcmds.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include "access/htup_details.h"
18 #include "access/table.h"
19 #include "access/xact.h"
20 #include "catalog/dependency.h"
21 #include "catalog/indexing.h"
22 #include "catalog/namespace.h"
23 #include "catalog/objectaccess.h"
24 #include "catalog/pg_collation.h"
25 #include "catalog/pg_database.h"
26 #include "catalog/pg_namespace.h"
27 #include "commands/alter.h"
28 #include "commands/collationcmds.h"
29 #include "commands/comment.h"
30 #include "commands/dbcommands.h"
31 #include "commands/defrem.h"
32 #include "common/string.h"
33 #include "mb/pg_wchar.h"
34 #include "miscadmin.h"
35 #include "utils/acl.h"
36 #include "utils/builtins.h"
37 #include "utils/lsyscache.h"
38 #include "utils/pg_locale.h"
39 #include "utils/rel.h"
40 #include "utils/syscache.h"
41 
42 
43 typedef struct
44 {
45  char *localename; /* name of locale, as per "locale -a" */
46  char *alias; /* shortened alias for same */
47  int enc; /* encoding */
49 
50 
51 /*
52  * CREATE COLLATION
53  */
55 DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
56 {
57  char *collName;
58  Oid collNamespace;
59  AclResult aclresult;
60  ListCell *pl;
61  DefElem *fromEl = NULL;
62  DefElem *localeEl = NULL;
63  DefElem *lccollateEl = NULL;
64  DefElem *lcctypeEl = NULL;
65  DefElem *providerEl = NULL;
66  DefElem *deterministicEl = NULL;
67  DefElem *rulesEl = NULL;
68  DefElem *versionEl = NULL;
69  char *collcollate;
70  char *collctype;
71  char *colliculocale;
72  char *collicurules;
73  bool collisdeterministic;
74  int collencoding;
75  char collprovider;
76  char *collversion = NULL;
77  Oid newoid;
78  ObjectAddress address;
79 
80  collNamespace = QualifiedNameGetCreationNamespace(names, &collName);
81 
82  aclresult = object_aclcheck(NamespaceRelationId, collNamespace, GetUserId(), ACL_CREATE);
83  if (aclresult != ACLCHECK_OK)
84  aclcheck_error(aclresult, OBJECT_SCHEMA,
85  get_namespace_name(collNamespace));
86 
87  foreach(pl, parameters)
88  {
89  DefElem *defel = lfirst_node(DefElem, pl);
90  DefElem **defelp;
91 
92  if (strcmp(defel->defname, "from") == 0)
93  defelp = &fromEl;
94  else if (strcmp(defel->defname, "locale") == 0)
95  defelp = &localeEl;
96  else if (strcmp(defel->defname, "lc_collate") == 0)
97  defelp = &lccollateEl;
98  else if (strcmp(defel->defname, "lc_ctype") == 0)
99  defelp = &lcctypeEl;
100  else if (strcmp(defel->defname, "provider") == 0)
101  defelp = &providerEl;
102  else if (strcmp(defel->defname, "deterministic") == 0)
103  defelp = &deterministicEl;
104  else if (strcmp(defel->defname, "rules") == 0)
105  defelp = &rulesEl;
106  else if (strcmp(defel->defname, "version") == 0)
107  defelp = &versionEl;
108  else
109  {
110  ereport(ERROR,
111  (errcode(ERRCODE_SYNTAX_ERROR),
112  errmsg("collation attribute \"%s\" not recognized",
113  defel->defname),
114  parser_errposition(pstate, defel->location)));
115  break;
116  }
117  if (*defelp != NULL)
118  errorConflictingDefElem(defel, pstate);
119  *defelp = defel;
120  }
121 
122  if (localeEl && (lccollateEl || lcctypeEl))
123  ereport(ERROR,
124  errcode(ERRCODE_SYNTAX_ERROR),
125  errmsg("conflicting or redundant options"),
126  errdetail("LOCALE cannot be specified together with LC_COLLATE or LC_CTYPE."));
127 
128  if (fromEl && list_length(parameters) != 1)
129  ereport(ERROR,
130  errcode(ERRCODE_SYNTAX_ERROR),
131  errmsg("conflicting or redundant options"),
132  errdetail("FROM cannot be specified together with any other options."));
133 
134  if (fromEl)
135  {
136  Oid collid;
137  HeapTuple tp;
138  Datum datum;
139  bool isnull;
140 
141  collid = get_collation_oid(defGetQualifiedName(fromEl), false);
143  if (!HeapTupleIsValid(tp))
144  elog(ERROR, "cache lookup failed for collation %u", collid);
145 
146  collprovider = ((Form_pg_collation) GETSTRUCT(tp))->collprovider;
147  collisdeterministic = ((Form_pg_collation) GETSTRUCT(tp))->collisdeterministic;
148  collencoding = ((Form_pg_collation) GETSTRUCT(tp))->collencoding;
149 
150  datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collcollate, &isnull);
151  if (!isnull)
152  collcollate = TextDatumGetCString(datum);
153  else
154  collcollate = NULL;
155 
156  datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collctype, &isnull);
157  if (!isnull)
158  collctype = TextDatumGetCString(datum);
159  else
160  collctype = NULL;
161 
162  datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_colliculocale, &isnull);
163  if (!isnull)
164  colliculocale = TextDatumGetCString(datum);
165  else
166  colliculocale = NULL;
167 
168  /*
169  * When the ICU locale comes from an existing collation, do not
170  * canonicalize to a language tag.
171  */
172 
173  datum = SysCacheGetAttr(COLLOID, tp, Anum_pg_collation_collicurules, &isnull);
174  if (!isnull)
175  collicurules = TextDatumGetCString(datum);
176  else
177  collicurules = NULL;
178 
179  ReleaseSysCache(tp);
180 
181  /*
182  * Copying the "default" collation is not allowed because most code
183  * checks for DEFAULT_COLLATION_OID instead of COLLPROVIDER_DEFAULT,
184  * and so having a second collation with COLLPROVIDER_DEFAULT would
185  * not work and potentially confuse or crash some code. This could be
186  * fixed with some legwork.
187  */
188  if (collprovider == COLLPROVIDER_DEFAULT)
189  ereport(ERROR,
190  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
191  errmsg("collation \"default\" cannot be copied")));
192  }
193  else
194  {
195  char *collproviderstr = NULL;
196 
197  collcollate = NULL;
198  collctype = NULL;
199  colliculocale = NULL;
200  collicurules = NULL;
201 
202  if (providerEl)
203  collproviderstr = defGetString(providerEl);
204 
205  if (deterministicEl)
206  collisdeterministic = defGetBoolean(deterministicEl);
207  else
208  collisdeterministic = true;
209 
210  if (rulesEl)
211  collicurules = defGetString(rulesEl);
212 
213  if (versionEl)
214  collversion = defGetString(versionEl);
215 
216  if (collproviderstr)
217  {
218  if (pg_strcasecmp(collproviderstr, "icu") == 0)
219  collprovider = COLLPROVIDER_ICU;
220  else if (pg_strcasecmp(collproviderstr, "libc") == 0)
221  collprovider = COLLPROVIDER_LIBC;
222  else
223  ereport(ERROR,
224  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
225  errmsg("unrecognized collation provider: %s",
226  collproviderstr)));
227  }
228  else
229  collprovider = COLLPROVIDER_LIBC;
230 
231  if (localeEl)
232  {
233  if (collprovider == COLLPROVIDER_LIBC)
234  {
235  collcollate = defGetString(localeEl);
236  collctype = defGetString(localeEl);
237  }
238  else
239  colliculocale = defGetString(localeEl);
240  }
241 
242  if (lccollateEl)
243  collcollate = defGetString(lccollateEl);
244 
245  if (lcctypeEl)
246  collctype = defGetString(lcctypeEl);
247 
248  if (collprovider == COLLPROVIDER_LIBC)
249  {
250  if (!collcollate)
251  ereport(ERROR,
252  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
253  errmsg("parameter \"lc_collate\" must be specified")));
254 
255  if (!collctype)
256  ereport(ERROR,
257  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
258  errmsg("parameter \"lc_ctype\" must be specified")));
259  }
260  else if (collprovider == COLLPROVIDER_ICU)
261  {
262  if (!colliculocale)
263  ereport(ERROR,
264  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
265  errmsg("parameter \"locale\" must be specified")));
266 
267  /*
268  * During binary upgrade, preserve the locale string. Otherwise,
269  * canonicalize to a language tag.
270  */
271  if (!IsBinaryUpgrade)
272  {
273  char *langtag = icu_language_tag(colliculocale,
275 
276  if (langtag && strcmp(colliculocale, langtag) != 0)
277  {
278  ereport(NOTICE,
279  (errmsg("using standard form \"%s\" for ICU locale \"%s\"",
280  langtag, colliculocale)));
281 
282  colliculocale = langtag;
283  }
284  }
285 
286  icu_validate_locale(colliculocale);
287  }
288 
289  /*
290  * Nondeterministic collations are currently only supported with ICU
291  * because that's the only case where it can actually make a
292  * difference. So we can save writing the code for the other
293  * providers.
294  */
295  if (!collisdeterministic && collprovider != COLLPROVIDER_ICU)
296  ereport(ERROR,
297  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
298  errmsg("nondeterministic collations not supported with this provider")));
299 
300  if (collicurules && collprovider != COLLPROVIDER_ICU)
301  ereport(ERROR,
302  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
303  errmsg("ICU rules cannot be specified unless locale provider is ICU")));
304 
305  if (collprovider == COLLPROVIDER_ICU)
306  {
307 #ifdef USE_ICU
308  /*
309  * We could create ICU collations with collencoding == database
310  * encoding, but it seems better to use -1 so that it matches the
311  * way initdb would create ICU collations. However, only allow
312  * one to be created when the current database's encoding is
313  * supported. Otherwise the collation is useless, plus we get
314  * surprising behaviors like not being able to drop the collation.
315  *
316  * Skip this test when !USE_ICU, because the error we want to
317  * throw for that isn't thrown till later.
318  */
320  ereport(ERROR,
321  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
322  errmsg("current database's encoding is not supported with this provider")));
323 #endif
324  collencoding = -1;
325  }
326  else
327  {
328  collencoding = GetDatabaseEncoding();
329  check_encoding_locale_matches(collencoding, collcollate, collctype);
330  }
331  }
332 
333  if (!collversion)
334  collversion = get_collation_actual_version(collprovider, collprovider == COLLPROVIDER_ICU ? colliculocale : collcollate);
335 
336  newoid = CollationCreate(collName,
337  collNamespace,
338  GetUserId(),
339  collprovider,
340  collisdeterministic,
341  collencoding,
342  collcollate,
343  collctype,
344  colliculocale,
345  collicurules,
346  collversion,
347  if_not_exists,
348  false); /* not quiet */
349 
350  if (!OidIsValid(newoid))
351  return InvalidObjectAddress;
352 
353  /*
354  * Check that the locales can be loaded. NB: pg_newlocale_from_collation
355  * is only supposed to be called on non-C-equivalent locales.
356  */
358  if (!lc_collate_is_c(newoid) || !lc_ctype_is_c(newoid))
359  (void) pg_newlocale_from_collation(newoid);
360 
361  ObjectAddressSet(address, CollationRelationId, newoid);
362 
363  return address;
364 }
365 
366 /*
367  * Subroutine for ALTER COLLATION SET SCHEMA and RENAME
368  *
369  * Is there a collation with the same name of the given collation already in
370  * the given namespace? If so, raise an appropriate error message.
371  */
372 void
373 IsThereCollationInNamespace(const char *collname, Oid nspOid)
374 {
375  /* make sure the name doesn't already exist in new schema */
377  CStringGetDatum(collname),
379  ObjectIdGetDatum(nspOid)))
380  ereport(ERROR,
382  errmsg("collation \"%s\" for encoding \"%s\" already exists in schema \"%s\"",
383  collname, GetDatabaseEncodingName(),
384  get_namespace_name(nspOid))));
385 
386  /* mustn't match an any-encoding entry, either */
388  CStringGetDatum(collname),
389  Int32GetDatum(-1),
390  ObjectIdGetDatum(nspOid)))
391  ereport(ERROR,
393  errmsg("collation \"%s\" already exists in schema \"%s\"",
394  collname, get_namespace_name(nspOid))));
395 }
396 
397 /*
398  * ALTER COLLATION
399  */
402 {
403  Relation rel;
404  Oid collOid;
405  HeapTuple tup;
406  Form_pg_collation collForm;
407  Datum datum;
408  bool isnull;
409  char *oldversion;
410  char *newversion;
411  ObjectAddress address;
412 
413  rel = table_open(CollationRelationId, RowExclusiveLock);
414  collOid = get_collation_oid(stmt->collname, false);
415 
416  if (collOid == DEFAULT_COLLATION_OID)
417  ereport(ERROR,
418  (errmsg("cannot refresh version of default collation"),
419  errhint("Use ALTER DATABASE ... REFRESH COLLATION VERSION instead.")));
420 
421  if (!object_ownercheck(CollationRelationId, collOid, GetUserId()))
423  NameListToString(stmt->collname));
424 
426  if (!HeapTupleIsValid(tup))
427  elog(ERROR, "cache lookup failed for collation %u", collOid);
428 
429  collForm = (Form_pg_collation) GETSTRUCT(tup);
430  datum = SysCacheGetAttr(COLLOID, tup, Anum_pg_collation_collversion, &isnull);
431  oldversion = isnull ? NULL : TextDatumGetCString(datum);
432 
433  datum = SysCacheGetAttrNotNull(COLLOID, tup, collForm->collprovider == COLLPROVIDER_ICU ? Anum_pg_collation_colliculocale : Anum_pg_collation_collcollate);
434  newversion = get_collation_actual_version(collForm->collprovider, TextDatumGetCString(datum));
435 
436  /* cannot change from NULL to non-NULL or vice versa */
437  if ((!oldversion && newversion) || (oldversion && !newversion))
438  elog(ERROR, "invalid collation version change");
439  else if (oldversion && newversion && strcmp(newversion, oldversion) != 0)
440  {
441  bool nulls[Natts_pg_collation];
442  bool replaces[Natts_pg_collation];
443  Datum values[Natts_pg_collation];
444 
445  ereport(NOTICE,
446  (errmsg("changing version from %s to %s",
447  oldversion, newversion)));
448 
449  memset(values, 0, sizeof(values));
450  memset(nulls, false, sizeof(nulls));
451  memset(replaces, false, sizeof(replaces));
452 
453  values[Anum_pg_collation_collversion - 1] = CStringGetTextDatum(newversion);
454  replaces[Anum_pg_collation_collversion - 1] = true;
455 
456  tup = heap_modify_tuple(tup, RelationGetDescr(rel),
457  values, nulls, replaces);
458  }
459  else
460  ereport(NOTICE,
461  (errmsg("version has not changed")));
462 
463  CatalogTupleUpdate(rel, &tup->t_self, tup);
464 
465  InvokeObjectPostAlterHook(CollationRelationId, collOid, 0);
466 
467  ObjectAddressSet(address, CollationRelationId, collOid);
468 
469  heap_freetuple(tup);
470  table_close(rel, NoLock);
471 
472  return address;
473 }
474 
475 
476 Datum
478 {
479  Oid collid = PG_GETARG_OID(0);
480  char provider;
481  char *locale;
482  char *version;
483  Datum datum;
484 
485  if (collid == DEFAULT_COLLATION_OID)
486  {
487  /* retrieve from pg_database */
488 
490 
491  if (!HeapTupleIsValid(dbtup))
492  ereport(ERROR,
493  (errcode(ERRCODE_UNDEFINED_OBJECT),
494  errmsg("database with OID %u does not exist", MyDatabaseId)));
495 
497 
498  datum = SysCacheGetAttrNotNull(DATABASEOID, dbtup,
499  provider == COLLPROVIDER_ICU ?
500  Anum_pg_database_daticulocale : Anum_pg_database_datcollate);
501 
502  locale = TextDatumGetCString(datum);
503 
504  ReleaseSysCache(dbtup);
505  }
506  else
507  {
508  /* retrieve from pg_collation */
509 
511 
512  if (!HeapTupleIsValid(colltp))
513  ereport(ERROR,
514  (errcode(ERRCODE_UNDEFINED_OBJECT),
515  errmsg("collation with OID %u does not exist", collid)));
516 
517  provider = ((Form_pg_collation) GETSTRUCT(colltp))->collprovider;
518  Assert(provider != COLLPROVIDER_DEFAULT);
519  datum = SysCacheGetAttrNotNull(COLLOID, colltp,
520  provider == COLLPROVIDER_ICU ?
521  Anum_pg_collation_colliculocale : Anum_pg_collation_collcollate);
522 
523  locale = TextDatumGetCString(datum);
524 
525  ReleaseSysCache(colltp);
526  }
527 
529  if (version)
531  else
532  PG_RETURN_NULL();
533 }
534 
535 
536 /* will we use "locale -a" in pg_import_system_collations? */
537 #if !defined(WIN32)
538 #define READ_LOCALE_A_OUTPUT
539 #endif
540 
541 /* will we use EnumSystemLocalesEx in pg_import_system_collations? */
542 #ifdef WIN32
543 #define ENUM_SYSTEM_LOCALE
544 #endif
545 
546 
547 #ifdef READ_LOCALE_A_OUTPUT
548 /*
549  * "Normalize" a libc locale name, stripping off encoding tags such as
550  * ".utf8" (e.g., "en_US.utf8" -> "en_US", but "br_FR.iso885915@euro"
551  * -> "br_FR@euro"). Return true if a new, different name was
552  * generated.
553  */
554 static bool
555 normalize_libc_locale_name(char *new, const char *old)
556 {
557  char *n = new;
558  const char *o = old;
559  bool changed = false;
560 
561  while (*o)
562  {
563  if (*o == '.')
564  {
565  /* skip over encoding tag such as ".utf8" or ".UTF-8" */
566  o++;
567  while ((*o >= 'A' && *o <= 'Z')
568  || (*o >= 'a' && *o <= 'z')
569  || (*o >= '0' && *o <= '9')
570  || (*o == '-'))
571  o++;
572  changed = true;
573  }
574  else
575  *n++ = *o++;
576  }
577  *n = '\0';
578 
579  return changed;
580 }
581 
582 /*
583  * qsort comparator for CollAliasData items
584  */
585 static int
586 cmpaliases(const void *a, const void *b)
587 {
588  const CollAliasData *ca = (const CollAliasData *) a;
589  const CollAliasData *cb = (const CollAliasData *) b;
590 
591  /* comparing localename is enough because other fields are derived */
592  return strcmp(ca->localename, cb->localename);
593 }
594 #endif /* READ_LOCALE_A_OUTPUT */
595 
596 
597 #ifdef USE_ICU
598 /*
599  * Get a comment (specifically, the display name) for an ICU locale.
600  * The result is a palloc'd string, or NULL if we can't get a comment
601  * or find that it's not all ASCII. (We can *not* accept non-ASCII
602  * comments, because the contents of template0 must be encoding-agnostic.)
603  */
604 static char *
605 get_icu_locale_comment(const char *localename)
606 {
607  UErrorCode status;
608  UChar displayname[128];
609  int32 len_uchar;
610  int32 i;
611  char *result;
612 
613  status = U_ZERO_ERROR;
614  len_uchar = uloc_getDisplayName(localename, "en",
615  displayname, lengthof(displayname),
616  &status);
617  if (U_FAILURE(status))
618  return NULL; /* no good reason to raise an error */
619 
620  /* Check for non-ASCII comment (can't use pg_is_ascii for this) */
621  for (i = 0; i < len_uchar; i++)
622  {
623  if (displayname[i] > 127)
624  return NULL;
625  }
626 
627  /* OK, transcribe */
628  result = palloc(len_uchar + 1);
629  for (i = 0; i < len_uchar; i++)
630  result[i] = displayname[i];
631  result[len_uchar] = '\0';
632 
633  return result;
634 }
635 #endif /* USE_ICU */
636 
637 
638 /*
639  * Create a new collation using the input locale 'locale'. (subroutine for
640  * pg_import_system_collations())
641  *
642  * 'nspid' is the namespace id where the collation will be created.
643  *
644  * 'nvalidp' is incremented if the locale has a valid encoding.
645  *
646  * 'ncreatedp' is incremented if the collation is actually created. If the
647  * collation already exists it will quietly do nothing.
648  *
649  * The returned value is the encoding of the locale, -1 if the locale is not
650  * valid for creating a collation.
651  *
652  */
654 static int
655 create_collation_from_locale(const char *locale, int nspid,
656  int *nvalidp, int *ncreatedp)
657 {
658  int enc;
660 
661  /*
662  * Some systems have locale names that don't consist entirely of ASCII
663  * letters (such as "bokm&aring;l" or "fran&ccedil;ais"). This is pretty
664  * silly, since we need the locale itself to interpret the non-ASCII
665  * characters. We can't do much with those, so we filter them out.
666  */
668  {
669  elog(DEBUG1, "skipping locale with non-ASCII name: \"%s\"", locale);
670  return -1;
671  }
672 
674  if (enc < 0)
675  {
676  elog(DEBUG1, "skipping locale with unrecognized encoding: \"%s\"", locale);
677  return -1;
678  }
680  {
681  elog(DEBUG1, "skipping locale with client-only encoding: \"%s\"", locale);
682  return -1;
683  }
685  return -1; /* C/POSIX are already in the catalog */
686 
687  /* count valid locales found in operating system */
688  (*nvalidp)++;
689 
690  /*
691  * Create a collation named the same as the locale, but quietly doing
692  * nothing if it already exists. This is the behavior we need even at
693  * initdb time, because some versions of "locale -a" can report the same
694  * locale name more than once. And it's convenient for later import runs,
695  * too, since you just about always want to add on new locales without a
696  * lot of chatter about existing ones.
697  */
699  COLLPROVIDER_LIBC, true, enc,
700  locale, locale, NULL, NULL,
701  get_collation_actual_version(COLLPROVIDER_LIBC, locale),
702  true, true);
703  if (OidIsValid(collid))
704  {
705  (*ncreatedp)++;
706 
707  /* Must do CCI between inserts to handle duplicates correctly */
709  }
710 
711  return enc;
712 }
713 
714 
715 #ifdef ENUM_SYSTEM_LOCALE
716 /* parameter to be passed to the callback function win32_read_locale() */
717 typedef struct
718 {
719  Oid nspid;
720  int *ncreatedp;
721  int *nvalidp;
722 } CollParam;
723 
724 /*
725  * Callback function for EnumSystemLocalesEx() in
726  * pg_import_system_collations(). Creates a collation for every valid locale
727  * and a POSIX alias collation.
728  *
729  * The callback contract is to return TRUE to continue enumerating and FALSE
730  * to stop enumerating. We always want to continue.
731  */
732 static BOOL CALLBACK
733 win32_read_locale(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
734 {
735  CollParam *param = (CollParam *) lparam;
736  char localebuf[NAMEDATALEN];
737  int result;
738  int enc;
739 
740  (void) dwFlags;
741 
742  result = WideCharToMultiByte(CP_ACP, 0, pStr, -1, localebuf, NAMEDATALEN,
743  NULL, NULL);
744 
745  if (result == 0)
746  {
747  if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
748  elog(DEBUG1, "skipping locale with too-long name: \"%s\"", localebuf);
749  return TRUE;
750  }
751  if (localebuf[0] == '\0')
752  return TRUE;
753 
754  enc = create_collation_from_locale(localebuf, param->nspid,
755  param->nvalidp, param->ncreatedp);
756  if (enc < 0)
757  return TRUE;
758 
759  /*
760  * Windows will use hyphens between language and territory, where POSIX
761  * uses an underscore. Simply create a POSIX alias.
762  */
763  if (strchr(localebuf, '-'))
764  {
765  char alias[NAMEDATALEN];
766  Oid collid;
767 
768  strcpy(alias, localebuf);
769  for (char *p = alias; *p; p++)
770  if (*p == '-')
771  *p = '_';
772 
773  collid = CollationCreate(alias, param->nspid, GetUserId(),
774  COLLPROVIDER_LIBC, true, enc,
775  localebuf, localebuf, NULL, NULL,
776  get_collation_actual_version(COLLPROVIDER_LIBC, localebuf),
777  true, true);
778  if (OidIsValid(collid))
779  {
780  (*param->ncreatedp)++;
781 
783  }
784  }
785 
786  return TRUE;
787 }
788 #endif /* ENUM_SYSTEM_LOCALE */
789 
790 
791 /*
792  * pg_import_system_collations: add known system collations to pg_collation
793  */
794 Datum
796 {
797  Oid nspid = PG_GETARG_OID(0);
798  int ncreated = 0;
799 
800  if (!superuser())
801  ereport(ERROR,
802  (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
803  errmsg("must be superuser to import system collations")));
804 
806  ereport(ERROR,
807  (errcode(ERRCODE_UNDEFINED_SCHEMA),
808  errmsg("schema with OID %u does not exist", nspid)));
809 
810  /* Load collations known to libc, using "locale -a" to enumerate them */
811 #ifdef READ_LOCALE_A_OUTPUT
812  {
813  FILE *locale_a_handle;
814  char localebuf[LOCALE_NAME_BUFLEN];
815  int nvalid = 0;
816  Oid collid;
817  CollAliasData *aliases;
818  int naliases,
819  maxaliases,
820  i;
821 
822  /* expansible array of aliases */
823  maxaliases = 100;
824  aliases = (CollAliasData *) palloc(maxaliases * sizeof(CollAliasData));
825  naliases = 0;
826 
827  locale_a_handle = OpenPipeStream("locale -a", "r");
828  if (locale_a_handle == NULL)
829  ereport(ERROR,
831  errmsg("could not execute command \"%s\": %m",
832  "locale -a")));
833 
834  while (fgets(localebuf, sizeof(localebuf), locale_a_handle))
835  {
836  size_t len;
837  int enc;
838  char alias[LOCALE_NAME_BUFLEN];
839 
840  len = strlen(localebuf);
841 
842  if (len == 0 || localebuf[len - 1] != '\n')
843  {
844  elog(DEBUG1, "skipping locale with too-long name: \"%s\"", localebuf);
845  continue;
846  }
847  localebuf[len - 1] = '\0';
848 
849  enc = create_collation_from_locale(localebuf, nspid, &nvalid, &ncreated);
850  if (enc < 0)
851  continue;
852 
853  /*
854  * Generate aliases such as "en_US" in addition to "en_US.utf8"
855  * for ease of use. Note that collation names are unique per
856  * encoding only, so this doesn't clash with "en_US" for LATIN1,
857  * say.
858  *
859  * However, it might conflict with a name we'll see later in the
860  * "locale -a" output. So save up the aliases and try to add them
861  * after we've read all the output.
862  */
863  if (normalize_libc_locale_name(alias, localebuf))
864  {
865  if (naliases >= maxaliases)
866  {
867  maxaliases *= 2;
868  aliases = (CollAliasData *)
869  repalloc(aliases, maxaliases * sizeof(CollAliasData));
870  }
871  aliases[naliases].localename = pstrdup(localebuf);
872  aliases[naliases].alias = pstrdup(alias);
873  aliases[naliases].enc = enc;
874  naliases++;
875  }
876  }
877 
878  /*
879  * We don't check the return value of this, because we want to support
880  * the case where there "locale" command does not exist. (This is
881  * unusual but can happen on minimalized Linux distributions, for
882  * example.) We will warn below if no locales could be found.
883  */
884  ClosePipeStream(locale_a_handle);
885 
886  /*
887  * Before processing the aliases, sort them by locale name. The point
888  * here is that if "locale -a" gives us multiple locale names with the
889  * same encoding and base name, say "en_US.utf8" and "en_US.utf-8", we
890  * want to pick a deterministic one of them. First in ASCII sort
891  * order is a good enough rule. (Before PG 10, the code corresponding
892  * to this logic in initdb.c had an additional ordering rule, to
893  * prefer the locale name exactly matching the alias, if any. We
894  * don't need to consider that here, because we would have already
895  * created such a pg_collation entry above, and that one will win.)
896  */
897  if (naliases > 1)
898  qsort(aliases, naliases, sizeof(CollAliasData), cmpaliases);
899 
900  /* Now add aliases, ignoring any that match pre-existing entries */
901  for (i = 0; i < naliases; i++)
902  {
903  char *locale = aliases[i].localename;
904  char *alias = aliases[i].alias;
905  int enc = aliases[i].enc;
906 
908  COLLPROVIDER_LIBC, true, enc,
909  locale, locale, NULL, NULL,
910  get_collation_actual_version(COLLPROVIDER_LIBC, locale),
911  true, true);
912  if (OidIsValid(collid))
913  {
914  ncreated++;
915 
917  }
918  }
919 
920  /* Give a warning if "locale -a" seems to be malfunctioning */
921  if (nvalid == 0)
923  (errmsg("no usable system locales were found")));
924  }
925 #endif /* READ_LOCALE_A_OUTPUT */
926 
927  /*
928  * Load collations known to ICU
929  *
930  * We use uloc_countAvailable()/uloc_getAvailable() rather than
931  * ucol_countAvailable()/ucol_getAvailable(). The former returns a full
932  * set of language+region combinations, whereas the latter only returns
933  * language+region combinations if they are distinct from the language's
934  * base collation. So there might not be a de-DE or en-GB, which would be
935  * confusing.
936  */
937 #ifdef USE_ICU
938  {
939  int i;
940 
941  /*
942  * Start the loop at -1 to sneak in the root locale without too much
943  * code duplication.
944  */
945  for (i = -1; i < uloc_countAvailable(); i++)
946  {
947  const char *name;
948  char *langtag;
949  char *icucomment;
950  Oid collid;
951 
952  if (i == -1)
953  name = ""; /* ICU root locale */
954  else
955  name = uloc_getAvailable(i);
956 
957  langtag = icu_language_tag(name, ERROR);
958 
959  /*
960  * Be paranoid about not allowing any non-ASCII strings into
961  * pg_collation
962  */
963  if (!pg_is_ascii(langtag))
964  continue;
965 
966  collid = CollationCreate(psprintf("%s-x-icu", langtag),
967  nspid, GetUserId(),
968  COLLPROVIDER_ICU, true, -1,
969  NULL, NULL, langtag, NULL,
970  get_collation_actual_version(COLLPROVIDER_ICU, langtag),
971  true, true);
972  if (OidIsValid(collid))
973  {
974  ncreated++;
975 
977 
978  icucomment = get_icu_locale_comment(name);
979  if (icucomment)
980  CreateComments(collid, CollationRelationId, 0,
981  icucomment);
982  }
983  }
984  }
985 #endif /* USE_ICU */
986 
987  /* Load collations known to WIN32 */
988 #ifdef ENUM_SYSTEM_LOCALE
989  {
990  int nvalid = 0;
991  CollParam param;
992 
993  param.nspid = nspid;
994  param.ncreatedp = &ncreated;
995  param.nvalidp = &nvalid;
996 
997  /*
998  * Enumerate the locales that are either installed on or supported by
999  * the OS.
1000  */
1001  if (!EnumSystemLocalesEx(win32_read_locale, LOCALE_ALL,
1002  (LPARAM) &param, NULL))
1003  _dosmaperr(GetLastError());
1004 
1005  /* Give a warning if EnumSystemLocalesEx seems to be malfunctioning */
1006  if (nvalid == 0)
1007  ereport(WARNING,
1008  (errmsg("no usable system locales were found")));
1009  }
1010 #endif /* ENUM_SYSTEM_LOCALE */
1011 
1012  PG_RETURN_INT32(ncreated);
1013 }
AclResult
Definition: acl.h:181
@ ACLCHECK_OK
Definition: acl.h:182
@ ACLCHECK_NOT_OWNER
Definition: acl.h:184
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2669
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3760
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition: aclchk.c:3961
static Datum values[MAXATTR]
Definition: bootstrap.c:156
#define CStringGetTextDatum(s)
Definition: builtins.h:94
#define TextDatumGetCString(d)
Definition: builtins.h:95
signed int int32
Definition: c.h:483
#define lengthof(array)
Definition: c.h:777
#define OidIsValid(objectId)
Definition: c.h:764
Datum pg_collation_actual_version(PG_FUNCTION_ARGS)
static bool normalize_libc_locale_name(char *new, const char *old)
int nspid
int int * nvalidp
static int cmpaliases(const void *a, const void *b)
enc
pg_attribute_unused() static int create_collation_from_locale(const char *locale
ObjectAddress AlterCollation(AlterCollationStmt *stmt)
void IsThereCollationInNamespace(const char *collname, Oid nspOid)
Datum pg_import_system_collations(PG_FUNCTION_ARGS)
int int int * ncreatedp
Oid collid
ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists)
Definition: collationcmds.c:55
void CreateComments(Oid oid, Oid classoid, int32 subid, const char *comment)
Definition: comment.c:143
void check_encoding_locale_matches(int encoding, const char *collate, const char *ctype)
Definition: dbcommands.c:1506
bool defGetBoolean(DefElem *def)
Definition: define.c:108
List * defGetQualifiedName(DefElem *def)
Definition: define.c:253
char * defGetString(DefElem *def)
Definition: define.c:49
void errorConflictingDefElem(DefElem *defel, ParseState *pstate)
Definition: define.c:385
int errcode_for_file_access(void)
Definition: elog.c:881
int errdetail(const char *fmt,...)
Definition: elog.c:1202
int errhint(const char *fmt,...)
Definition: elog.c:1316
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define WARNING
Definition: elog.h:36
#define DEBUG1
Definition: elog.h:30
#define ERROR
Definition: elog.h:39
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:149
bool is_encoding_supported_by_icu(int encoding)
Definition: encnames.c:462
int ClosePipeStream(FILE *file)
Definition: fd.c:2936
FILE * OpenPipeStream(const char *command, const char *mode)
Definition: fd.c:2631
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
bool IsBinaryUpgrade
Definition: globals.c:114
Oid MyDatabaseId
Definition: globals.c:89
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *replValues, bool *replIsnull, bool *doReplace)
Definition: heaptuple.c:1201
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1426
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
#define stmt
Definition: indent_codes.h:59
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
Definition: indexing.c:313
static char * locale
Definition: initdb.c:140
int b
Definition: isn.c:70
int a
Definition: isn.c:69
int i
Definition: isn.c:73
static JitProviderCallbacks provider
Definition: jit.c:43
Assert(fmt[strlen(fmt) - 1] !='\n')
#define NoLock
Definition: lockdefs.h:34
#define RowExclusiveLock
Definition: lockdefs.h:38
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3348
int GetDatabaseEncoding(void)
Definition: mbutils.c:1268
const char * GetDatabaseEncodingName(void)
Definition: mbutils.c:1274
char * pstrdup(const char *in)
Definition: mcxt.c:1644
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1476
void * palloc(Size size)
Definition: mcxt.c:1226
Oid GetUserId(void)
Definition: miscinit.c:509
Oid QualifiedNameGetCreationNamespace(const List *names, char **objname_p)
Definition: namespace.c:3020
Oid get_collation_oid(List *collname, bool missing_ok)
Definition: namespace.c:3503
char * NameListToString(const List *names)
Definition: namespace.c:3127
#define InvokeObjectPostAlterHook(classId, objectId, subId)
Definition: objectaccess.h:197
const ObjectAddress InvalidObjectAddress
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
@ OBJECT_COLLATION
Definition: parsenodes.h:2127
@ OBJECT_SCHEMA
Definition: parsenodes.h:2156
#define ACL_CREATE
Definition: parsenodes.h:92
Oid CollationCreate(const char *collname, Oid collnamespace, Oid collowner, char collprovider, bool collisdeterministic, int32 collencoding, const char *collcollate, const char *collctype, const char *colliculocale, const char *collicurules, const char *collversion, bool if_not_exists, bool quiet)
Definition: pg_collation.c:46
FormData_pg_collation * Form_pg_collation
Definition: pg_collation.h:58
#define NAMEDATALEN
const void size_t len
char datlocprovider
Definition: pg_database.h:44
FormData_pg_database * Form_pg_database
Definition: pg_database.h:93
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
int icu_validation_level
Definition: pg_locale.c:103
bool lc_collate_is_c(Oid collation)
Definition: pg_locale.c:1307
void icu_validate_locale(const char *loc_str)
Definition: pg_locale.c:2853
pg_locale_t pg_newlocale_from_collation(Oid collid)
Definition: pg_locale.c:1514
bool lc_ctype_is_c(Oid collation)
Definition: pg_locale.c:1360
char * get_collation_actual_version(char collprovider, const char *collcollate)
Definition: pg_locale.c:1677
char * icu_language_tag(const char *loc_str, int elevel)
Definition: pg_locale.c:2796
#define LOCALE_NAME_BUFLEN
Definition: pg_locale.h:36
@ PG_SQL_ASCII
Definition: pg_wchar.h:226
#define PG_VALID_BE_ENCODING(_enc)
Definition: pg_wchar.h:281
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
int pg_get_encoding_from_locale(const char *ctype, bool write_message)
Definition: chklocale.c:428
#define qsort(a, b, c, d)
Definition: port.h:445
uintptr_t Datum
Definition: postgres.h:64
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
unsigned int Oid
Definition: postgres_ext.h:31
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
#define RelationGetDescr(relation)
Definition: rel.h:530
#define ERRCODE_DUPLICATE_OBJECT
Definition: streamutil.c:32
bool pg_is_ascii(const char *str)
Definition: string.c:133
char * localename
Definition: collationcmds.c:45
char * defname
Definition: parsenodes.h:809
int location
Definition: parsenodes.h:813
ItemPointerData t_self
Definition: htup.h:65
Definition: pg_list.h:54
bool superuser(void)
Definition: superuser.c:46
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:868
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:820
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:1081
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:1112
#define SearchSysCacheCopy1(cacheId, key1)
Definition: syscache.h:182
@ COLLOID
Definition: syscache.h:50
@ COLLNAMEENCNSP
Definition: syscache.h:49
@ DATABASEOID
Definition: syscache.h:55
@ NAMESPACEOID
Definition: syscache.h:70
#define SearchSysCacheExists1(cacheId, key1)
Definition: syscache.h:191
#define SearchSysCacheExists3(cacheId, key1, key2, key3)
Definition: syscache.h:195
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
text * cstring_to_text(const char *s)
Definition: varlena.c:182
const char * name
void _dosmaperr(unsigned long)
Definition: win32error.c:177
void CommandCounterIncrement(void)
Definition: xact.c:1078