Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * dict_synonym.c
4 : * Synonym dictionary: replace word by its synonym
5 : *
6 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : *
8 : *
9 : * IDENTIFICATION
10 : * src/backend/tsearch/dict_synonym.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 : #include "postgres.h"
15 :
16 : #include "catalog/pg_collation_d.h"
17 : #include "commands/defrem.h"
18 : #include "tsearch/ts_locale.h"
19 : #include "tsearch/ts_public.h"
20 : #include "utils/fmgrprotos.h"
21 : #include "utils/formatting.h"
22 :
23 : typedef struct
24 : {
25 : char *in;
26 : char *out;
27 : uint16 flags;
28 : } Syn;
29 :
30 : typedef struct
31 : {
32 : int len; /* length of syn array */
33 : Syn *syn;
34 : bool case_sensitive;
35 : } DictSyn;
36 :
37 : /*
38 : * Finds the next whitespace-delimited word within the 'in' string.
39 : * Returns a pointer to the first character of the word, and a pointer
40 : * to the next byte after the last character in the word (in *end).
41 : * Character '*' at the end of word will not be treated as word
42 : * character if flags is not null.
43 : */
44 : static char *
45 290 : findwrd(char *in, char **end, uint16 *flags)
46 : {
47 : char *start;
48 : char *lastchar;
49 :
50 : /* Skip leading spaces */
51 290 : while (*in && isspace((unsigned char) *in))
52 0 : in += pg_mblen_cstr(in);
53 :
54 : /* Return NULL on empty lines */
55 290 : if (*in == '\0')
56 : {
57 0 : *end = NULL;
58 0 : return NULL;
59 : }
60 :
61 290 : lastchar = start = in;
62 :
63 : /* Find end of word */
64 2117 : while (*in && !isspace((unsigned char) *in))
65 : {
66 1827 : lastchar = in;
67 1827 : in += pg_mblen_cstr(in);
68 : }
69 :
70 290 : if (in - lastchar == 1 && t_iseq(lastchar, '*') && flags)
71 : {
72 29 : *flags = TSL_PREFIX;
73 29 : *end = lastchar;
74 : }
75 : else
76 : {
77 261 : if (flags)
78 116 : *flags = 0;
79 261 : *end = in;
80 : }
81 :
82 290 : return start;
83 : }
84 :
85 : static int
86 1010 : compareSyn(const void *a, const void *b)
87 : {
88 1010 : return strcmp(((const Syn *) a)->in, ((const Syn *) b)->in);
89 : }
90 :
91 :
92 : Datum
93 33 : dsynonym_init(PG_FUNCTION_ARGS)
94 : {
95 33 : List *dictoptions = (List *) PG_GETARG_POINTER(0);
96 : DictSyn *d;
97 : ListCell *l;
98 33 : char *filename = NULL;
99 33 : bool case_sensitive = false;
100 : tsearch_readline_state trst;
101 : char *starti,
102 : *starto,
103 33 : *end = NULL;
104 33 : int cur = 0;
105 33 : char *line = NULL;
106 33 : uint16 flags = 0;
107 :
108 87 : foreach(l, dictoptions)
109 : {
110 58 : DefElem *defel = (DefElem *) lfirst(l);
111 :
112 58 : if (strcmp(defel->defname, "synonyms") == 0)
113 33 : filename = defGetString(defel);
114 25 : else if (strcmp(defel->defname, "casesensitive") == 0)
115 25 : case_sensitive = defGetBoolean(defel);
116 : else
117 0 : ereport(ERROR,
118 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
119 : errmsg("unrecognized synonym parameter: \"%s\"",
120 : defel->defname)));
121 : }
122 :
123 29 : if (!filename)
124 0 : ereport(ERROR,
125 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
126 : errmsg("missing Synonyms parameter")));
127 :
128 29 : filename = get_tsearch_config_filename(filename, "syn");
129 :
130 29 : if (!tsearch_readline_begin(&trst, filename))
131 0 : ereport(ERROR,
132 : (errcode(ERRCODE_CONFIG_FILE_ERROR),
133 : errmsg("could not open synonym file \"%s\": %m",
134 : filename)));
135 :
136 29 : d = palloc0_object(DictSyn);
137 :
138 174 : while ((line = tsearch_readline(&trst)) != NULL)
139 : {
140 145 : starti = findwrd(line, &end, NULL);
141 145 : if (!starti)
142 : {
143 : /* Empty line */
144 0 : goto skipline;
145 : }
146 145 : if (*end == '\0')
147 : {
148 : /* A line with only one word. Ignore silently. */
149 0 : goto skipline;
150 : }
151 145 : *end = '\0';
152 :
153 145 : starto = findwrd(end + 1, &end, &flags);
154 145 : if (!starto)
155 : {
156 : /* A line with only one word (+whitespace). Ignore silently. */
157 0 : goto skipline;
158 : }
159 145 : *end = '\0';
160 :
161 : /*
162 : * starti now points to the first word, and starto to the second word
163 : * on the line, with a \0 terminator at the end of both words.
164 : */
165 :
166 145 : if (cur >= d->len)
167 : {
168 29 : if (d->len == 0)
169 : {
170 29 : d->len = 64;
171 29 : d->syn = palloc_array(Syn, d->len);
172 : }
173 : else
174 : {
175 0 : d->len *= 2;
176 0 : d->syn = repalloc_array(d->syn, Syn, d->len);
177 : }
178 : }
179 :
180 145 : if (case_sensitive)
181 : {
182 40 : d->syn[cur].in = pstrdup(starti);
183 40 : d->syn[cur].out = pstrdup(starto);
184 : }
185 : else
186 : {
187 105 : d->syn[cur].in = str_tolower(starti, strlen(starti), DEFAULT_COLLATION_OID);
188 105 : d->syn[cur].out = str_tolower(starto, strlen(starto), DEFAULT_COLLATION_OID);
189 : }
190 :
191 145 : d->syn[cur].flags = flags;
192 :
193 145 : cur++;
194 :
195 145 : skipline:
196 145 : pfree(line);
197 : }
198 :
199 29 : tsearch_readline_end(&trst);
200 29 : pfree(filename);
201 :
202 29 : d->len = cur;
203 29 : qsort(d->syn, d->len, sizeof(Syn), compareSyn);
204 :
205 29 : d->case_sensitive = case_sensitive;
206 :
207 29 : PG_RETURN_POINTER(d);
208 : }
209 :
210 : Datum
211 305 : dsynonym_lexize(PG_FUNCTION_ARGS)
212 : {
213 305 : DictSyn *d = (DictSyn *) PG_GETARG_POINTER(0);
214 305 : char *in = (char *) PG_GETARG_POINTER(1);
215 305 : int32 len = PG_GETARG_INT32(2);
216 : Syn key,
217 : *found;
218 : TSLexeme *res;
219 :
220 : /* note: d->len test protects against Solaris bsearch-of-no-items bug */
221 305 : if (len <= 0 || d->len <= 0)
222 0 : PG_RETURN_POINTER(NULL);
223 :
224 305 : if (d->case_sensitive)
225 5 : key.in = pnstrdup(in, len);
226 : else
227 300 : key.in = str_tolower(in, len, DEFAULT_COLLATION_OID);
228 :
229 305 : key.out = NULL;
230 :
231 305 : found = (Syn *) bsearch(&key, d->syn, d->len, sizeof(Syn), compareSyn);
232 305 : pfree(key.in);
233 :
234 305 : if (!found)
235 250 : PG_RETURN_POINTER(NULL);
236 :
237 55 : res = palloc0_array(TSLexeme, 2);
238 55 : res[0].lexeme = pstrdup(found->out);
239 55 : res[0].flags = found->flags;
240 :
241 55 : PG_RETURN_POINTER(res);
242 : }
|
