Debian Codegraph @

src/backend/utils/adt/tsginidx.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * tsginidx.c
4 * GIN support functions for tsvector_ops
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 *
8 *
9 * IDENTIFICATION
10 * src/backend/utils/adt/tsginidx.c
11 *
12 *-------------------------------------------------------------------------
13 */
14 #include "postgres.h"
15
16 #include "access/gin.h"
17 #include "tsearch/ts_type.h"
18 #include "tsearch/ts_utils.h"
19 #include "utils/builtins.h"
20 #include "varatt.h"
21
22
23 Datum
24 gin_cmp_tslexeme(PG_FUNCTION_ARGS)
25 {
26 text *a = PG_GETARG_TEXT_PP(0);
27 text *b = PG_GETARG_TEXT_PP(1);
28 int cmp;
29
30 cmp = tsCompareString(VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
31 VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
32 false);
33
34 PG_FREE_IF_COPY(a, 0);
35 PG_FREE_IF_COPY(b, 1);
36 PG_RETURN_INT32(cmp);
37 }
38
39 Datum
40 gin_cmp_prefix(PG_FUNCTION_ARGS)
41 {
42 text *a = PG_GETARG_TEXT_PP(0);
43 text *b = PG_GETARG_TEXT_PP(1);
44
45 #ifdef NOT_USED
46 StrategyNumber strategy = PG_GETARG_UINT16(2);
47 Pointer extra_data = PG_GETARG_POINTER(3);
48 #endif
49 int cmp;
50
51 cmp = tsCompareString(VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
52 VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
53 true);
54
55 if (cmp < 0)
56 cmp = 1; /* prevent continue scan */
57
58 PG_FREE_IF_COPY(a, 0);
59 PG_FREE_IF_COPY(b, 1);
60 PG_RETURN_INT32(cmp);
61 }
62
63 Datum
64 gin_extract_tsvector(PG_FUNCTION_ARGS)
65 {
66 TSVector vector = PG_GETARG_TSVECTOR(0);
67 int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
68 Datum *entries = NULL;
69
70 *nentries = vector->size;
71 if (vector->size > 0)
72 {
73 int i;
74 WordEntry *we = ARRPTR(vector);
75
76 entries = (Datum *) palloc(sizeof(Datum) * vector->size);
77
78 for (i = 0; i < vector->size; i++)
79 {
80 text *txt;
81
82 txt = cstring_to_text_with_len(STRPTR(vector) + we->pos, we->len);
83 entries[i] = PointerGetDatum(txt);
84
85 we++;
86 }
87 }
88
89 PG_FREE_IF_COPY(vector, 0);
90 PG_RETURN_POINTER(entries);
91 }
92
93 Datum
94 gin_extract_tsquery(PG_FUNCTION_ARGS)
95 {
96 TSQuery query = PG_GETARG_TSQUERY(0);
97 int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
98
99 /* StrategyNumber strategy = PG_GETARG_UINT16(2); */
100 bool **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3);
101 Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
102
103 /* bool **nullFlags = (bool **) PG_GETARG_POINTER(5); */
104 int32 *searchMode = (int32 *) PG_GETARG_POINTER(6);
105 Datum *entries = NULL;
106
107 *nentries = 0;
108
109 if (query->size > 0)
110 {
111 QueryItem *item = GETQUERY(query);
112 int32 i,
113 j;
114 bool *partialmatch;
115 int *map_item_operand;
116
117 /*
118 * If the query doesn't have any required positive matches (for
119 * instance, it's something like '! foo'), we have to do a full index
120 * scan.
121 */
122 if (tsquery_requires_match(item))
123 *searchMode = GIN_SEARCH_MODE_DEFAULT;
124 else
125 *searchMode = GIN_SEARCH_MODE_ALL;
126
127 /* count number of VAL items */
128 j = 0;
129 for (i = 0; i < query->size; i++)
130 {
131 if (item[i].type == QI_VAL)
132 j++;
133 }
134 *nentries = j;
135
136 entries = (Datum *) palloc(sizeof(Datum) * j);
137 partialmatch = *ptr_partialmatch = (bool *) palloc(sizeof(bool) * j);
138
139 /*
140 * Make map to convert item's number to corresponding operand's (the
141 * same, entry's) number. Entry's number is used in check array in
142 * consistent method. We use the same map for each entry.
143 */
144 *extra_data = (Pointer *) palloc(sizeof(Pointer) * j);
145 map_item_operand = (int *) palloc0(sizeof(int) * query->size);
146
147 /* Now rescan the VAL items and fill in the arrays */
148 j = 0;
149 for (i = 0; i < query->size; i++)
150 {
151 if (item[i].type == QI_VAL)
152 {
153 QueryOperand *val = &item[i].qoperand;
154 text *txt;
155
156 txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,
157 val->length);
158 entries[j] = PointerGetDatum(txt);
159 partialmatch[j] = val->prefix;
160 (*extra_data)[j] = (Pointer) map_item_operand;
161 map_item_operand[i] = j;
162 j++;
163 }
164 }
165 }
166
167 PG_FREE_IF_COPY(query, 0);
168
169 PG_RETURN_POINTER(entries);
170 }
171
172 typedef struct
173 {
174 QueryItem *first_item;
175 GinTernaryValue *check;
176 int *map_item_operand;
177 } GinChkVal;
178
179 /*
180 * TS_execute callback for matching a tsquery operand to GIN index data
181 */
182 static TSTernaryValue
183 checkcondition_gin(void *checkval, QueryOperand *val, ExecPhraseData *data)
184 {
185 GinChkVal *gcv = (GinChkVal *) checkval;
186 int j;
187 GinTernaryValue result;
188
189 /* convert item's number to corresponding entry's (operand's) number */
190 j = gcv->map_item_operand[((QueryItem *) val) - gcv->first_item];
191
192 /* determine presence of current entry in indexed value */
193 result = gcv->check[j];
194
195 /*
196 * If any val requiring a weight is used or caller needs position
197 * information then we must recheck, so replace TRUE with MAYBE.
198 */
199 if (result == GIN_TRUE)
200 {
201 if (val->weight != 0 || data != NULL)
202 result = GIN_MAYBE;
203 }
204
205 /*
206 * We rely on GinTernaryValue and TSTernaryValue using equivalent value
207 * assignments. We could use a switch statement to map the values if that
208 * ever stops being true, but it seems unlikely to happen.
209 */
210 return (TSTernaryValue) result;
211 }
212
213 Datum
214 gin_tsquery_consistent(PG_FUNCTION_ARGS)
215 {
216 bool *check = (bool *) PG_GETARG_POINTER(0);
217
218 /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
219 TSQuery query = PG_GETARG_TSQUERY(2);
220
221 /* int32 nkeys = PG_GETARG_INT32(3); */
222 Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
223 bool *recheck = (bool *) PG_GETARG_POINTER(5);
224 bool res = false;
225
226 /* Initially assume query doesn't require recheck */
227 *recheck = false;
228
229 if (query->size > 0)
230 {
231 GinChkVal gcv;
232
233 /*
234 * check-parameter array has one entry for each value (operand) in the
235 * query.
236 */
237 gcv.first_item = GETQUERY(query);
238 gcv.check = (GinTernaryValue *) check;
239 gcv.map_item_operand = (int *) (extra_data[0]);
240
241 switch (TS_execute_ternary(GETQUERY(query),
242 &gcv,
243 TS_EXEC_PHRASE_NO_POS,
244 checkcondition_gin))
245 {
246 case TS_NO:
247 res = false;
248 break;
249 case TS_YES:
250 res = true;
251 break;
252 case TS_MAYBE:
253 res = true;
254 *recheck = true;
255 break;
256 }
257 }
258
259 PG_RETURN_BOOL(res);
260 }
261
262 Datum
263 gin_tsquery_triconsistent(PG_FUNCTION_ARGS)
264 {
265 GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
266
267 /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
268 TSQuery query = PG_GETARG_TSQUERY(2);
269
270 /* int32 nkeys = PG_GETARG_INT32(3); */
271 Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
272 GinTernaryValue res = GIN_FALSE;
273
274 if (query->size > 0)
275 {
276 GinChkVal gcv;
277
278 /*
279 * check-parameter array has one entry for each value (operand) in the
280 * query.
281 */
282 gcv.first_item = GETQUERY(query);
283 gcv.check = check;
284 gcv.map_item_operand = (int *) (extra_data[0]);
285
286 res = TS_execute_ternary(GETQUERY(query),
287 &gcv,
288 TS_EXEC_PHRASE_NO_POS,
289 checkcondition_gin);
290 }
291
292 PG_RETURN_GIN_TERNARY_VALUE(res);
293 }
294
295 /*
296 * Formerly, gin_extract_tsvector had only two arguments. Now it has three,
297 * but we still need a pg_proc entry with two args to support reloading
298 * pre-9.1 contrib/tsearch2 opclass declarations. This compatibility
299 * function should go away eventually. (Note: you might say "hey, but the
300 * code above is only *using* two args, so let's just declare it that way".
301 * If you try that you'll find the opr_sanity regression test complains.)
302 */
303 Datum
304 gin_extract_tsvector_2args(PG_FUNCTION_ARGS)
305 {
306 if (PG_NARGS() < 3) /* should not happen */
307 elog(ERROR, "gin_extract_tsvector requires three arguments");
308 return gin_extract_tsvector(fcinfo);
309 }
310
311 /*
312 * Likewise, we need a stub version of gin_extract_tsquery declared with
313 * only five arguments.
314 */
315 Datum
316 gin_extract_tsquery_5args(PG_FUNCTION_ARGS)
317 {
318 if (PG_NARGS() < 7) /* should not happen */
319 elog(ERROR, "gin_extract_tsquery requires seven arguments");
320 return gin_extract_tsquery(fcinfo);
321 }
322
323 /*
324 * Likewise, we need a stub version of gin_tsquery_consistent declared with
325 * only six arguments.
326 */
327 Datum
328 gin_tsquery_consistent_6args(PG_FUNCTION_ARGS)
329 {
330 if (PG_NARGS() < 8) /* should not happen */
331 elog(ERROR, "gin_tsquery_consistent requires eight arguments");
332 return gin_tsquery_consistent(fcinfo);
333 }
334
335 /*
336 * Likewise, a stub version of gin_extract_tsquery declared with argument
337 * types that are no longer considered appropriate.
338 */
339 Datum
340 gin_extract_tsquery_oldsig(PG_FUNCTION_ARGS)
341 {
342 return gin_extract_tsquery(fcinfo);
343 }
344
345 /*
346 * Likewise, a stub version of gin_tsquery_consistent declared with argument
347 * types that are no longer considered appropriate.
348 */
349 Datum
350 gin_tsquery_consistent_oldsig(PG_FUNCTION_ARGS)
351 {
352 return gin_tsquery_consistent(fcinfo);
353 }