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