Debian Codegraph @

src/backend/utils/adt/pg_locale_builtin.c

raw
1 /*-----------------------------------------------------------------------
2 *
3 * PostgreSQL locale utilities for builtin provider
4 *
5 * Portions Copyright (c) 2002-2025, PostgreSQL Global Development Group
6 *
7 * src/backend/utils/adt/pg_locale_builtin.c
8 *
9 *-----------------------------------------------------------------------
10 */
11
12 #include "postgres.h"
13
14 #include "catalog/pg_database.h"
15 #include "catalog/pg_collation.h"
16 #include "common/unicode_case.h"
17 #include "common/unicode_category.h"
18 #include "mb/pg_wchar.h"
19 #include "miscadmin.h"
20 #include "utils/builtins.h"
21 #include "utils/memutils.h"
22 #include "utils/pg_locale.h"
23 #include "utils/syscache.h"
24
25 extern pg_locale_t create_pg_locale_builtin(Oid collid,
26 MemoryContext context);
27 extern char *get_collation_actual_version_builtin(const char *collcollate);
28 extern size_t strlower_builtin(char *dest, size_t destsize, const char *src,
29 ssize_t srclen, pg_locale_t locale);
30 extern size_t strtitle_builtin(char *dest, size_t destsize, const char *src,
31 ssize_t srclen, pg_locale_t locale);
32 extern size_t strupper_builtin(char *dest, size_t destsize, const char *src,
33 ssize_t srclen, pg_locale_t locale);
34 extern size_t strfold_builtin(char *dest, size_t destsize, const char *src,
35 ssize_t srclen, pg_locale_t locale);
36
37
38 struct WordBoundaryState
39 {
40 const char *str;
41 size_t len;
42 size_t offset;
43 bool posix;
44 bool init;
45 bool prev_alnum;
46 };
47
48 /*
49 * Simple word boundary iterator that draws boundaries each time the result of
50 * pg_u_isalnum() changes.
51 */
52 static size_t
53 initcap_wbnext(void *state)
54 {
55 struct WordBoundaryState *wbstate = (struct WordBoundaryState *) state;
56
57 while (wbstate->offset < wbstate->len &&
58 wbstate->str[wbstate->offset] != '\0')
59 {
60 int ulen = pg_utf_mblen((const unsigned char *) wbstate->str +
61 wbstate->offset);
62 pg_wchar u;
63 bool curr_alnum;
64 size_t prev_offset = wbstate->offset;
65
66 /* invalid UTF8 */
67 if (wbstate->offset + ulen > wbstate->len)
68 {
69 wbstate->init = true;
70 wbstate->offset = wbstate->len;
71 return prev_offset;
72 }
73
74 u = utf8_to_unicode((const unsigned char *) wbstate->str +
75 wbstate->offset);
76 curr_alnum = pg_u_isalnum(u, wbstate->posix);
77
78 if (!wbstate->init || curr_alnum != wbstate->prev_alnum)
79 {
80 wbstate->init = true;
81 wbstate->offset += ulen;
82 wbstate->prev_alnum = curr_alnum;
83 return prev_offset;
84 }
85
86 wbstate->offset += ulen;
87 }
88
89 return wbstate->len;
90 }
91
92 size_t
93 strlower_builtin(char *dest, size_t destsize, const char *src, ssize_t srclen,
94 pg_locale_t locale)
95 {
96 return unicode_strlower(dest, destsize, src, srclen,
97 locale->info.builtin.casemap_full);
98 }
99
100 size_t
101 strtitle_builtin(char *dest, size_t destsize, const char *src, ssize_t srclen,
102 pg_locale_t locale)
103 {
104 struct WordBoundaryState wbstate = {
105 .str = src,
106 .len = (srclen < 0) ? strlen(src) : srclen,
107 .offset = 0,
108 .posix = !locale->info.builtin.casemap_full,
109 .init = false,
110 .prev_alnum = false,
111 };
112
113 return unicode_strtitle(dest, destsize, src, srclen,
114 locale->info.builtin.casemap_full,
115 initcap_wbnext, &wbstate);
116 }
117
118 size_t
119 strupper_builtin(char *dest, size_t destsize, const char *src, ssize_t srclen,
120 pg_locale_t locale)
121 {
122 return unicode_strupper(dest, destsize, src, srclen,
123 locale->info.builtin.casemap_full);
124 }
125
126 size_t
127 strfold_builtin(char *dest, size_t destsize, const char *src, ssize_t srclen,
128 pg_locale_t locale)
129 {
130 return unicode_strfold(dest, destsize, src, srclen,
131 locale->info.builtin.casemap_full);
132 }
133
134 pg_locale_t
135 create_pg_locale_builtin(Oid collid, MemoryContext context)
136 {
137 const char *locstr;
138 pg_locale_t result;
139
140 if (collid == DEFAULT_COLLATION_OID)
141 {
142 HeapTuple tp;
143 Datum datum;
144
145 tp = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId));
146 if (!HeapTupleIsValid(tp))
147 elog(ERROR, "cache lookup failed for database %u", MyDatabaseId);
148 datum = SysCacheGetAttrNotNull(DATABASEOID, tp,
149 Anum_pg_database_datlocale);
150 locstr = TextDatumGetCString(datum);
151 ReleaseSysCache(tp);
152 }
153 else
154 {
155 HeapTuple tp;
156 Datum datum;
157
158 tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
159 if (!HeapTupleIsValid(tp))
160 elog(ERROR, "cache lookup failed for collation %u", collid);
161 datum = SysCacheGetAttrNotNull(COLLOID, tp,
162 Anum_pg_collation_colllocale);
163 locstr = TextDatumGetCString(datum);
164 ReleaseSysCache(tp);
165 }
166
167 builtin_validate_locale(GetDatabaseEncoding(), locstr);
168
169 result = MemoryContextAllocZero(context, sizeof(struct pg_locale_struct));
170
171 result->info.builtin.locale = MemoryContextStrdup(context, locstr);
172 result->info.builtin.casemap_full = (strcmp(locstr, "PG_UNICODE_FAST") == 0);
173 result->provider = COLLPROVIDER_BUILTIN;
174 result->deterministic = true;
175 result->collate_is_c = true;
176 result->ctype_is_c = (strcmp(locstr, "C") == 0);
177
178 return result;
179 }
180
181 char *
182 get_collation_actual_version_builtin(const char *collcollate)
183 {
184 /*
185 * The only two supported locales (C and C.UTF-8) are both based on memcmp
186 * and are not expected to change, but track the version anyway.
187 *
188 * Note that the character semantics may change for some locales, but the
189 * collation version only tracks changes to sort order.
190 */
191 if (strcmp(collcollate, "C") == 0)
192 return "1";
193 else if (strcmp(collcollate, "C.UTF-8") == 0)
194 return "1";
195 else if (strcmp(collcollate, "PG_UNICODE_FAST") == 0)
196 return "1";
197 else
198 ereport(ERROR,
199 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
200 errmsg("invalid locale name \"%s\" for builtin provider",
201 collcollate)));
202
203 return NULL; /* keep compiler quiet */
204 }