PostgreSQL Source Code: contrib/pg_trgm/trgm_gin.c Source File

PostgreSQL Source Code git master
trgm_gin.c
Go to the documentation of this file.
1/*
2 * contrib/pg_trgm/trgm_gin.c
3 */
4#include "postgres.h"
5
6#include "access/gin.h"
7#include "access/stratnum.h"
8#include "fmgr.h"
9#include "trgm.h"
10#include "varatt.h"
11
12 PG_FUNCTION_INFO_V1(gin_extract_trgm);
13 PG_FUNCTION_INFO_V1(gin_extract_value_trgm);
14 PG_FUNCTION_INFO_V1(gin_extract_query_trgm);
15 PG_FUNCTION_INFO_V1(gin_trgm_consistent);
16 PG_FUNCTION_INFO_V1(gin_trgm_triconsistent);
17
18/*
19 * This function can only be called if a pre-9.1 version of the GIN operator
20 * class definition is present in the catalogs (probably as a consequence
21 * of upgrade-in-place). Cope.
22 */
23Datum
24 gin_extract_trgm(PG_FUNCTION_ARGS)
25{
26 if (PG_NARGS() == 3)
27 return gin_extract_value_trgm(fcinfo);
28 if (PG_NARGS() == 7)
29 return gin_extract_query_trgm(fcinfo);
30 elog(ERROR, "unexpected number of arguments to gin_extract_trgm");
31 PG_RETURN_NULL();
32}
33
34Datum
35 gin_extract_value_trgm(PG_FUNCTION_ARGS)
36{
37 text *val = (text *) PG_GETARG_TEXT_PP(0);
38 int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
39 Datum *entries = NULL;
40 TRGM *trg;
41 int32 trglen;
42
43 *nentries = 0;
44
45 trg = generate_trgm(VARDATA_ANY(val), VARSIZE_ANY_EXHDR(val));
46 trglen = ARRNELEM(trg);
47
48 if (trglen > 0)
49 {
50 trgm *ptr;
51 int32 i;
52
53 *nentries = trglen;
54 entries = (Datum *) palloc(sizeof(Datum) * trglen);
55
56 ptr = GETARR(trg);
57 for (i = 0; i < trglen; i++)
58 {
59 int32 item = trgm2int(ptr);
60
61 entries[i] = Int32GetDatum(item);
62 ptr++;
63 }
64 }
65
66 PG_RETURN_POINTER(entries);
67}
68
69Datum
70 gin_extract_query_trgm(PG_FUNCTION_ARGS)
71{
72 text *val = (text *) PG_GETARG_TEXT_PP(0);
73 int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
74 StrategyNumber strategy = PG_GETARG_UINT16(2);
75
76 /* bool **pmatch = (bool **) PG_GETARG_POINTER(3); */
77 Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
78
79 /* bool **nullFlags = (bool **) PG_GETARG_POINTER(5); */
80 int32 *searchMode = (int32 *) PG_GETARG_POINTER(6);
81 Datum *entries = NULL;
82 TRGM *trg;
83 int32 trglen;
84 trgm *ptr;
85 TrgmPackedGraph *graph;
86 int32 i;
87
88 switch (strategy)
89 {
90 case SimilarityStrategyNumber:
91 case WordSimilarityStrategyNumber:
92 case StrictWordSimilarityStrategyNumber:
93 case EqualStrategyNumber:
94 trg = generate_trgm(VARDATA_ANY(val), VARSIZE_ANY_EXHDR(val));
95 break;
96 case ILikeStrategyNumber:
97#ifndef IGNORECASE
98 elog(ERROR, "cannot handle ~~* with case-sensitive trigrams");
99#endif
100 /* FALL THRU */
101 case LikeStrategyNumber:
102
103 /*
104 * For wildcard search we extract all the trigrams that every
105 * potentially-matching string must include.
106 */
107 trg = generate_wildcard_trgm(VARDATA_ANY(val),
108 VARSIZE_ANY_EXHDR(val));
109 break;
110 case RegExpICaseStrategyNumber:
111#ifndef IGNORECASE
112 elog(ERROR, "cannot handle ~* with case-sensitive trigrams");
113#endif
114 /* FALL THRU */
115 case RegExpStrategyNumber:
116 trg = createTrgmNFA(val, PG_GET_COLLATION(),
117 &graph, CurrentMemoryContext);
118 if (trg && ARRNELEM(trg) > 0)
119 {
120 /*
121 * Successful regex processing: store NFA-like graph as
122 * extra_data. GIN API requires an array of nentries
123 * Pointers, but we just put the same value in each element.
124 */
125 trglen = ARRNELEM(trg);
126 *extra_data = (Pointer *) palloc(sizeof(Pointer) * trglen);
127 for (i = 0; i < trglen; i++)
128 (*extra_data)[i] = (Pointer) graph;
129 }
130 else
131 {
132 /* No result: have to do full index scan. */
133 *nentries = 0;
134 *searchMode = GIN_SEARCH_MODE_ALL;
135 PG_RETURN_POINTER(entries);
136 }
137 break;
138 default:
139 elog(ERROR, "unrecognized strategy number: %d", strategy);
140 trg = NULL; /* keep compiler quiet */
141 break;
142 }
143
144 trglen = ARRNELEM(trg);
145 *nentries = trglen;
146
147 if (trglen > 0)
148 {
149 entries = (Datum *) palloc(sizeof(Datum) * trglen);
150 ptr = GETARR(trg);
151 for (i = 0; i < trglen; i++)
152 {
153 int32 item = trgm2int(ptr);
154
155 entries[i] = Int32GetDatum(item);
156 ptr++;
157 }
158 }
159
160 /*
161 * If no trigram was extracted then we have to scan all the index.
162 */
163 if (trglen == 0)
164 *searchMode = GIN_SEARCH_MODE_ALL;
165
166 PG_RETURN_POINTER(entries);
167}
168
169Datum
170 gin_trgm_consistent(PG_FUNCTION_ARGS)
171{
172 bool *check = (bool *) PG_GETARG_POINTER(0);
173 StrategyNumber strategy = PG_GETARG_UINT16(1);
174
175 /* text *query = PG_GETARG_TEXT_PP(2); */
176 int32 nkeys = PG_GETARG_INT32(3);
177 Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
178 bool *recheck = (bool *) PG_GETARG_POINTER(5);
179 bool res;
180 int32 i,
181 ntrue;
182 double nlimit;
183
184 /* All cases served by this function are inexact */
185 *recheck = true;
186
187 switch (strategy)
188 {
189 case SimilarityStrategyNumber:
190 case WordSimilarityStrategyNumber:
191 case StrictWordSimilarityStrategyNumber:
192 nlimit = index_strategy_get_limit(strategy);
193
194 /* Count the matches */
195 ntrue = 0;
196 for (i = 0; i < nkeys; i++)
197 {
198 if (check[i])
199 ntrue++;
200 }
201
202 /*--------------------
203 * If DIVUNION is defined then similarity formula is:
204 * c / (len1 + len2 - c)
205 * where c is number of common trigrams and it stands as ntrue in
206 * this code. Here we don't know value of len2 but we can assume
207 * that c (ntrue) is a lower bound of len2, so upper bound of
208 * similarity is:
209 * c / (len1 + c - c) => c / len1
210 * If DIVUNION is not defined then similarity formula is:
211 * c / max(len1, len2)
212 * And again, c (ntrue) is a lower bound of len2, but c <= len1
213 * just by definition and, consequently, upper bound of
214 * similarity is just c / len1.
215 * So, independently on DIVUNION the upper bound formula is the same.
216 */
217 res = (nkeys == 0) ? false :
218 (((((float4) ntrue) / ((float4) nkeys))) >= nlimit);
219 break;
220 case ILikeStrategyNumber:
221#ifndef IGNORECASE
222 elog(ERROR, "cannot handle ~~* with case-sensitive trigrams");
223#endif
224 /* FALL THRU */
225 case LikeStrategyNumber:
226 case EqualStrategyNumber:
227 /* Check if all extracted trigrams are presented. */
228 res = true;
229 for (i = 0; i < nkeys; i++)
230 {
231 if (!check[i])
232 {
233 res = false;
234 break;
235 }
236 }
237 break;
238 case RegExpICaseStrategyNumber:
239#ifndef IGNORECASE
240 elog(ERROR, "cannot handle ~* with case-sensitive trigrams");
241#endif
242 /* FALL THRU */
243 case RegExpStrategyNumber:
244 if (nkeys < 1)
245 {
246 /* Regex processing gave no result: do full index scan */
247 res = true;
248 }
249 else
250 res = trigramsMatchGraph((TrgmPackedGraph *) extra_data[0],
251 check);
252 break;
253 default:
254 elog(ERROR, "unrecognized strategy number: %d", strategy);
255 res = false; /* keep compiler quiet */
256 break;
257 }
258
259 PG_RETURN_BOOL(res);
260}
261
262/*
263 * In all cases, GIN_TRUE is at least as favorable to inclusion as
264 * GIN_MAYBE. If no better option is available, simply treat
265 * GIN_MAYBE as if it were GIN_TRUE and apply the same test as the binary
266 * consistent function.
267 */
268Datum
269 gin_trgm_triconsistent(PG_FUNCTION_ARGS)
270{
271 GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
272 StrategyNumber strategy = PG_GETARG_UINT16(1);
273
274 /* text *query = PG_GETARG_TEXT_PP(2); */
275 int32 nkeys = PG_GETARG_INT32(3);
276 Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
277 GinTernaryValue res = GIN_MAYBE;
278 int32 i,
279 ntrue;
280 bool *boolcheck;
281 double nlimit;
282
283 switch (strategy)
284 {
285 case SimilarityStrategyNumber:
286 case WordSimilarityStrategyNumber:
287 case StrictWordSimilarityStrategyNumber:
288 nlimit = index_strategy_get_limit(strategy);
289
290 /* Count the matches */
291 ntrue = 0;
292 for (i = 0; i < nkeys; i++)
293 {
294 if (check[i] != GIN_FALSE)
295 ntrue++;
296 }
297
298 /*
299 * See comment in gin_trgm_consistent() about * upper bound
300 * formula
301 */
302 res = (nkeys == 0)
303 ? GIN_FALSE : (((((float4) ntrue) / ((float4) nkeys)) >= nlimit)
304 ? GIN_MAYBE : GIN_FALSE);
305 break;
306 case ILikeStrategyNumber:
307#ifndef IGNORECASE
308 elog(ERROR, "cannot handle ~~* with case-sensitive trigrams");
309#endif
310 /* FALL THRU */
311 case LikeStrategyNumber:
312 case EqualStrategyNumber:
313 /* Check if all extracted trigrams are presented. */
314 res = GIN_MAYBE;
315 for (i = 0; i < nkeys; i++)
316 {
317 if (check[i] == GIN_FALSE)
318 {
319 res = GIN_FALSE;
320 break;
321 }
322 }
323 break;
324 case RegExpICaseStrategyNumber:
325#ifndef IGNORECASE
326 elog(ERROR, "cannot handle ~* with case-sensitive trigrams");
327#endif
328 /* FALL THRU */
329 case RegExpStrategyNumber:
330 if (nkeys < 1)
331 {
332 /* Regex processing gave no result: do full index scan */
333 res = GIN_MAYBE;
334 }
335 else
336 {
337 /*
338 * As trigramsMatchGraph implements a monotonic boolean
339 * function, promoting all GIN_MAYBE keys to GIN_TRUE will
340 * give a conservative result.
341 */
342 boolcheck = (bool *) palloc(sizeof(bool) * nkeys);
343 for (i = 0; i < nkeys; i++)
344 boolcheck[i] = (check[i] != GIN_FALSE);
345 if (!trigramsMatchGraph((TrgmPackedGraph *) extra_data[0],
346 boolcheck))
347 res = GIN_FALSE;
348 pfree(boolcheck);
349 }
350 break;
351 default:
352 elog(ERROR, "unrecognized strategy number: %d", strategy);
353 res = GIN_FALSE; /* keep compiler quiet */
354 break;
355 }
356
357 /* All cases served by this function are inexact */
358 Assert(res != GIN_TRUE);
359 PG_RETURN_GIN_TERNARY_VALUE(res);
360}
char * Pointer
Definition: c.h:529
int32_t int32
Definition: c.h:534
float float4
Definition: c.h:634
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define PG_NARGS()
Definition: fmgr.h:203
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_UINT16(n)
Definition: fmgr.h:272
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_GET_COLLATION()
Definition: fmgr.h:198
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define PG_RETURN_GIN_TERNARY_VALUE(x)
Definition: gin.h:92
#define GIN_SEARCH_MODE_ALL
Definition: gin.h:38
#define GIN_FALSE
Definition: gin.h:76
char GinTernaryValue
Definition: gin.h:71
#define GIN_MAYBE
Definition: gin.h:78
#define GIN_TRUE
Definition: gin.h:77
Assert(PointerIsAligned(start, uint64))
long val
Definition: informix.c:689
i
int i
Definition: isn.c:77
void pfree(void *pointer)
Definition: mcxt.c:1594
void * palloc(Size size)
Definition: mcxt.c:1365
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
uint64_t Datum
Definition: postgres.h:70
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:222
uint16 StrategyNumber
Definition: stratnum.h:22
Definition: trgm.h:58
Definition: c.h:692
#define RegExpICaseStrategyNumber
Definition: trgm.h:34
#define WordSimilarityStrategyNumber
Definition: trgm.h:35
TRGM * generate_trgm(char *str, int slen)
Definition: trgm_op.c:406
#define StrictWordSimilarityStrategyNumber
Definition: trgm.h:37
uint32 trgm2int(trgm *ptr)
Definition: trgm_op.c:985
#define ARRNELEM(x)
Definition: trgm.h:98
double index_strategy_get_limit(StrategyNumber strategy)
Definition: trgm_op.c:182
TRGM * createTrgmNFA(text *text_re, Oid collation, TrgmPackedGraph **graph, MemoryContext rcontext)
Definition: trgm_regexp.c:524
#define SimilarityStrategyNumber
Definition: trgm.h:29
bool trigramsMatchGraph(TrgmPackedGraph *graph, bool *check)
Definition: trgm_regexp.c:628
char trgm[3]
Definition: trgm.h:41
#define ILikeStrategyNumber
Definition: trgm.h:32
TRGM * generate_wildcard_trgm(const char *str, int slen)
Definition: trgm_op.c:916
#define LikeStrategyNumber
Definition: trgm.h:31
#define GETARR(x)
Definition: trgm.h:97
#define EqualStrategyNumber
Definition: trgm.h:39
#define RegExpStrategyNumber
Definition: trgm.h:33
Datum gin_trgm_consistent(PG_FUNCTION_ARGS)
Definition: trgm_gin.c:170
Datum gin_trgm_triconsistent(PG_FUNCTION_ARGS)
Definition: trgm_gin.c:269
Datum gin_extract_value_trgm(PG_FUNCTION_ARGS)
Definition: trgm_gin.c:35
Datum gin_extract_query_trgm(PG_FUNCTION_ARGS)
Definition: trgm_gin.c:70
Datum gin_extract_trgm(PG_FUNCTION_ARGS)
Definition: trgm_gin.c:24
PG_FUNCTION_INFO_V1(gin_extract_trgm)
static Size VARSIZE_ANY_EXHDR(const void *PTR)
Definition: varatt.h:472
static char * VARDATA_ANY(const void *PTR)
Definition: varatt.h:486

AltStyle によって変換されたページ (->オリジナル) /