Age Owner Branch data TLA Line data Source code
1 : : /*
2 : : * contrib/pg_trgm/trgm_gist.c
3 : : */
4 : : #include "postgres.h"
5 : :
6 : : #include "access/reloptions.h"
7 : : #include "access/stratnum.h"
8 : : #include "fmgr.h"
9 : : #include "port/pg_bitutils.h"
10 : : #include "trgm.h"
11 : : #include "varatt.h"
12 : :
13 : : /* gist_trgm_ops opclass options */
14 : : typedef struct
15 : : {
16 : : int32 vl_len_; /* varlena header (do not touch directly!) */
17 : : int siglen; /* signature length in bytes */
18 : : } TrgmGistOptions;
19 : :
20 : : #define GET_SIGLEN() (PG_HAS_OPCLASS_OPTIONS() ? \
21 : : ((TrgmGistOptions *) PG_GET_OPCLASS_OPTIONS())->siglen : \
22 : : SIGLEN_DEFAULT)
23 : :
24 : : typedef struct
25 : : {
26 : : /* most recent inputs to gtrgm_consistent */
27 : : StrategyNumber strategy;
28 : : text *query;
29 : : /* extracted trigrams for query */
30 : : TRGM *trigrams;
31 : : /* if a regex operator, the extracted graph */
32 : : TrgmPackedGraph *graph;
33 : :
34 : : /*
35 : : * The "query" and "trigrams" are stored in the same palloc block as this
36 : : * cache struct, at MAXALIGN'ed offsets. The graph however isn't.
37 : : */
38 : : } gtrgm_consistent_cache;
39 : :
40 : : #define GETENTRY(vec,pos) ((TRGM *) DatumGetPointer((vec)->vector[(pos)].key))
41 : :
42 : :
8065 teodor@sigaev.ru 43 :CBC 1 : PG_FUNCTION_INFO_V1(gtrgm_in);
44 : 1 : PG_FUNCTION_INFO_V1(gtrgm_out);
45 : 5 : PG_FUNCTION_INFO_V1(gtrgm_compress);
46 : 5 : PG_FUNCTION_INFO_V1(gtrgm_decompress);
47 : 5 : PG_FUNCTION_INFO_V1(gtrgm_consistent);
5687 tgl@sss.pgh.pa.us 48 : 5 : PG_FUNCTION_INFO_V1(gtrgm_distance);
8065 teodor@sigaev.ru 49 : 5 : PG_FUNCTION_INFO_V1(gtrgm_union);
50 : 5 : PG_FUNCTION_INFO_V1(gtrgm_same);
51 : 5 : PG_FUNCTION_INFO_V1(gtrgm_penalty);
52 : 5 : PG_FUNCTION_INFO_V1(gtrgm_picksplit);
2283 akorotkov@postgresql 53 : 5 : PG_FUNCTION_INFO_V1(gtrgm_options);
54 : :
55 : :
56 : : Datum
8065 teodor@sigaev.ru 57 :UBC 0 : gtrgm_in(PG_FUNCTION_ARGS)
58 : : {
1298 tgl@sss.pgh.pa.us 59 [ # # ]: 0 : ereport(ERROR,
60 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
61 : : errmsg("cannot accept a value of type %s", "gtrgm")));
62 : :
63 : : PG_RETURN_VOID(); /* keep compiler quiet */
64 : : }
65 : :
66 : : Datum
8065 teodor@sigaev.ru 67 : 0 : gtrgm_out(PG_FUNCTION_ARGS)
68 : : {
1298 tgl@sss.pgh.pa.us 69 [ # # ]: 0 : ereport(ERROR,
70 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
71 : : errmsg("cannot display a value of type %s", "gtrgm")));
72 : :
73 : : PG_RETURN_VOID(); /* keep compiler quiet */
74 : : }
75 : :
76 : : static TRGM *
2283 akorotkov@postgresql 77 :CBC 28152 : gtrgm_alloc(bool isalltrue, int siglen, BITVECP sign)
78 : : {
79 [ - + ]: 28152 : int flag = SIGNKEY | (isalltrue ? ALLISTRUE : 0);
80 [ - + + - ]: 28152 : int size = CALCGTSIZE(flag, siglen);
81 : 28152 : TRGM *res = palloc(size);
82 : :
83 : 28152 : SET_VARSIZE(res, size);
84 : 28152 : res->flag = flag;
85 : :
86 [ + - ]: 28152 : if (!isalltrue)
87 : : {
88 [ + + ]: 28152 : if (sign)
89 : 566 : memcpy(GETSIGN(res), sign, siglen);
90 : : else
91 : 27586 : memset(GETSIGN(res), 0, siglen);
92 : : }
93 : :
94 : 28152 : return res;
95 : : }
96 : :
97 : : static void
98 : 47732 : makesign(BITVECP sign, TRGM *a, int siglen)
99 : : {
100 : : int32 k,
8065 teodor@sigaev.ru 101 : 47732 : len = ARRNELEM(a);
102 : 47732 : trgm *ptr = GETARR(a);
5118 peter_e@gmx.net 103 : 47732 : int32 tmp = 0;
104 : :
1239 peter@eisentraut.org 105 [ + + + + : 47732 : MemSet(sign, 0, siglen);
+ - - + -
- ]
2283 akorotkov@postgresql 106 : 47732 : SETBIT(sign, SIGLENBIT(siglen)); /* set last unused bit */
7975 bruce@momjian.us 107 [ + + ]: 469968 : for (k = 0; k < len; k++)
108 : : {
495 peter@eisentraut.org 109 : 422236 : CPTRGM(&tmp, ptr + k);
2283 akorotkov@postgresql 110 : 422236 : HASH(sign, tmp, siglen);
111 : : }
8065 teodor@sigaev.ru 112 : 47732 : }
113 : :
114 : : Datum
115 : 27841 : gtrgm_compress(PG_FUNCTION_ARGS)
116 : : {
117 : 27841 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
2056 akorotkov@postgresql 118 [ + - ]: 27841 : int siglen = GET_SIGLEN();
8065 teodor@sigaev.ru 119 : 27841 : GISTENTRY *retval = entry;
120 : :
121 [ + + ]: 27841 : if (entry->leafkey)
122 : : { /* trgm */
123 : : TRGM *res;
3397 noah@leadboat.com 124 : 24452 : text *val = DatumGetTextPP(entry->key);
125 : :
126 [ - + - - : 24452 : res = generate_trgm(VARDATA_ANY(val), VARSIZE_ANY_EXHDR(val));
- - - - +
- + - ]
207 michael@paquier.xyz 127 :GNC 24452 : retval = palloc_object(GISTENTRY);
8065 teodor@sigaev.ru 128 :CBC 24452 : gistentryinit(*retval, PointerGetDatum(res),
129 : : entry->rel, entry->page,
130 : : entry->offset, false);
131 : : }
132 [ + - ]: 3389 : else if (ISSIGNKEY(DatumGetPointer(entry->key)) &&
133 [ + - ]: 3389 : !ISALLTRUE(DatumGetPointer(entry->key)))
134 : : {
135 : : int32 i;
136 : : TRGM *res;
137 : 3389 : BITVECP sign = GETSIGN(DatumGetPointer(entry->key));
138 : :
2283 akorotkov@postgresql 139 [ + - ]: 3565 : LOOPBYTE(siglen)
140 : : {
6801 bruce@momjian.us 141 [ + + ]: 3565 : if ((sign[i] & 0xff) != 0xff)
142 : 3389 : PG_RETURN_POINTER(retval);
143 : : }
144 : :
2283 akorotkov@postgresql 145 :UBC 0 : res = gtrgm_alloc(true, siglen, sign);
207 michael@paquier.xyz 146 :UNC 0 : retval = palloc_object(GISTENTRY);
8065 teodor@sigaev.ru 147 :UBC 0 : gistentryinit(*retval, PointerGetDatum(res),
148 : : entry->rel, entry->page,
149 : : entry->offset, false);
150 : : }
8065 teodor@sigaev.ru 151 :CBC 24452 : PG_RETURN_POINTER(retval);
152 : : }
153 : :
154 : : Datum
155 : 1353327 : gtrgm_decompress(PG_FUNCTION_ARGS)
156 : : {
7025 tgl@sss.pgh.pa.us 157 : 1353327 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
158 : : GISTENTRY *retval;
159 : : text *key;
160 : :
3397 noah@leadboat.com 161 : 1353327 : key = DatumGetTextPP(entry->key);
162 : :
7025 tgl@sss.pgh.pa.us 163 [ - + ]: 1353327 : if (key != (text *) DatumGetPointer(entry->key))
164 : : {
165 : : /* need to pass back the decompressed item */
207 michael@paquier.xyz 166 :UNC 0 : retval = palloc_object(GISTENTRY);
7025 tgl@sss.pgh.pa.us 167 :UBC 0 : gistentryinit(*retval, PointerGetDatum(key),
168 : : entry->rel, entry->page, entry->offset, entry->leafkey);
169 : 0 : PG_RETURN_POINTER(retval);
170 : : }
171 : : else
172 : : {
173 : : /* we can return the entry as-is */
7025 tgl@sss.pgh.pa.us 174 :CBC 1353327 : PG_RETURN_POINTER(entry);
175 : : }
176 : : }
177 : :
178 : : static int32
2283 akorotkov@postgresql 179 : 656 : cnt_sml_sign_common(TRGM *qtrg, BITVECP sign, int siglen)
180 : : {
5118 peter_e@gmx.net 181 : 656 : int32 count = 0;
182 : : int32 k,
5687 tgl@sss.pgh.pa.us 183 : 656 : len = ARRNELEM(qtrg);
184 : 656 : trgm *ptr = GETARR(qtrg);
5118 peter_e@gmx.net 185 : 656 : int32 tmp = 0;
186 : :
5687 tgl@sss.pgh.pa.us 187 [ + + ]: 6070 : for (k = 0; k < len; k++)
188 : : {
495 peter@eisentraut.org 189 : 5414 : CPTRGM(&tmp, ptr + k);
2283 akorotkov@postgresql 190 : 5414 : count += GETBIT(sign, HASHVAL(tmp, siglen));
191 : : }
192 : :
5687 tgl@sss.pgh.pa.us 193 : 656 : return count;
194 : : }
195 : :
196 : : Datum
8065 teodor@sigaev.ru 197 : 37406 : gtrgm_consistent(PG_FUNCTION_ARGS)
198 : : {
6651 tgl@sss.pgh.pa.us 199 : 37406 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
200 : 37406 : text *query = PG_GETARG_TEXT_P(1);
5687 201 : 37406 : StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
202 : : #ifdef NOT_USED
203 : : Oid subtype = PG_GETARG_OID(3);
204 : : #endif
6651 205 : 37406 : bool *recheck = (bool *) PG_GETARG_POINTER(4);
2056 akorotkov@postgresql 206 [ + - ]: 37406 : int siglen = GET_SIGLEN();
6651 tgl@sss.pgh.pa.us 207 : 37406 : TRGM *key = (TRGM *) DatumGetPointer(entry->key);
208 : : TRGM *qtrg;
209 : : bool res;
5387 210 : 37406 : Size querysize = VARSIZE(query);
211 : : gtrgm_consistent_cache *cache;
212 : : double nlimit;
213 : :
214 : : /*
215 : : * We keep the extracted trigrams in cache, because trigram extraction is
216 : : * relatively CPU-expensive. When trying to reuse a cached value, check
217 : : * strategy number not just query itself, because trigram extraction
218 : : * depends on strategy.
219 : : *
220 : : * The cached structure is a single palloc chunk containing the
221 : : * gtrgm_consistent_cache header, then the input query (4-byte length
222 : : * word, uncompressed, starting at a MAXALIGN boundary), then the TRGM
223 : : * value (also starting at a MAXALIGN boundary). However we don't try to
224 : : * include the regex graph (if any) in that struct. (XXX currently, this
225 : : * approach can leak regex graphs across index rescans. Not clear if
226 : : * that's worth fixing.)
227 : : */
4829 228 : 37406 : cache = (gtrgm_consistent_cache *) fcinfo->flinfo->fn_extra;
5387 229 [ + + ]: 37406 : if (cache == NULL ||
4829 230 [ + - + - ]: 74700 : cache->strategy != strategy ||
231 [ + - ]: 37350 : VARSIZE(cache->query) != querysize ||
503 peter@eisentraut.org 232 [ - + ]: 37350 : memcmp(cache->query, query, querysize) != 0)
233 : : {
234 : : gtrgm_consistent_cache *newcache;
4829 tgl@sss.pgh.pa.us 235 : 56 : TrgmPackedGraph *graph = NULL;
236 : : Size qtrgsize;
237 : :
5629 238 [ + + + - ]: 56 : switch (strategy)
239 : : {
240 : 28 : case SimilarityStrategyNumber:
241 : : case WordSimilarityStrategyNumber:
242 : : case StrictWordSimilarityStrategyNumber:
243 : : case EqualStrategyNumber:
5387 244 : 28 : qtrg = generate_trgm(VARDATA(query),
245 : 28 : querysize - VARHDRSZ);
5629 246 : 28 : break;
247 : 7 : case ILikeStrategyNumber:
248 : : #ifndef IGNORECASE
249 : : elog(ERROR, "cannot handle ~~* with case-sensitive trigrams");
250 : : #endif
251 : : pg_fallthrough;
252 : : case LikeStrategyNumber:
5387 253 : 7 : qtrg = generate_wildcard_trgm(VARDATA(query),
254 : 7 : querysize - VARHDRSZ);
5629 255 : 7 : break;
4829 256 : 21 : case RegExpICaseStrategyNumber:
257 : : #ifndef IGNORECASE
258 : : elog(ERROR, "cannot handle ~* with case-sensitive trigrams");
259 : : #endif
260 : : pg_fallthrough;
261 : : case RegExpStrategyNumber:
262 : 21 : qtrg = createTrgmNFA(query, PG_GET_COLLATION(),
263 : 21 : &graph, fcinfo->flinfo->fn_mcxt);
264 : : /* just in case an empty array is returned ... */
265 [ + + - + ]: 21 : if (qtrg && ARRNELEM(qtrg) <= 0)
266 : : {
4829 tgl@sss.pgh.pa.us 267 :UBC 0 : pfree(qtrg);
268 : 0 : qtrg = NULL;
269 : : }
4829 tgl@sss.pgh.pa.us 270 :CBC 21 : break;
5629 tgl@sss.pgh.pa.us 271 :UBC 0 : default:
272 [ # # ]: 0 : elog(ERROR, "unrecognized strategy number: %d", strategy);
273 : : qtrg = NULL; /* keep compiler quiet */
274 : : break;
275 : : }
276 : :
4829 tgl@sss.pgh.pa.us 277 [ + + ]:CBC 56 : qtrgsize = qtrg ? VARSIZE(qtrg) : 0;
278 : :
279 : : newcache = (gtrgm_consistent_cache *)
280 : 56 : MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
281 : : MAXALIGN(sizeof(gtrgm_consistent_cache)) +
282 : 56 : MAXALIGN(querysize) +
283 : : qtrgsize);
284 : :
285 : 56 : newcache->strategy = strategy;
286 : 56 : newcache->query = (text *)
287 : : ((char *) newcache + MAXALIGN(sizeof(gtrgm_consistent_cache)));
503 peter@eisentraut.org 288 : 56 : memcpy(newcache->query, query, querysize);
4829 tgl@sss.pgh.pa.us 289 [ + + ]: 56 : if (qtrg)
290 : : {
291 : 52 : newcache->trigrams = (TRGM *)
292 : 52 : ((char *) newcache->query + MAXALIGN(querysize));
503 peter@eisentraut.org 293 : 52 : memcpy((char *) newcache->trigrams, qtrg, qtrgsize);
294 : : /* release qtrg in case it was made in fn_mcxt */
4829 tgl@sss.pgh.pa.us 295 : 52 : pfree(qtrg);
296 : : }
297 : : else
298 : 4 : newcache->trigrams = NULL;
299 : 56 : newcache->graph = graph;
300 : :
6563 teodor@sigaev.ru 301 [ - + ]: 56 : if (cache)
6563 teodor@sigaev.ru 302 :UBC 0 : pfree(cache);
579 peter@eisentraut.org 303 :CBC 56 : fcinfo->flinfo->fn_extra = newcache;
4829 tgl@sss.pgh.pa.us 304 : 56 : cache = newcache;
305 : : }
306 : :
307 : 37406 : qtrg = cache->trigrams;
308 : :
5687 309 [ + + + - ]: 37406 : switch (strategy)
310 : : {
311 : 35000 : case SimilarityStrategyNumber:
312 : : case WordSimilarityStrategyNumber:
313 : : case StrictWordSimilarityStrategyNumber:
314 : :
315 : : /*
316 : : * Similarity search is exact. (Strict) word similarity search is
317 : : * inexact
318 : : */
3023 teodor@sigaev.ru 319 : 35000 : *recheck = (strategy != SimilarityStrategyNumber);
320 : :
321 : 35000 : nlimit = index_strategy_get_limit(strategy);
322 : :
5687 tgl@sss.pgh.pa.us 323 [ + + ]: 35000 : if (GIST_LEAF(entry))
324 : : { /* all leafs contains orig trgm */
3662 325 : 34386 : double tmpsml = cnt_sml(qtrg, key, *recheck);
326 : :
327 : 34386 : res = (tmpsml >= nlimit);
328 : : }
5687 329 [ - + ]: 614 : else if (ISALLTRUE(key))
330 : : { /* non-leaf contains signature */
5687 tgl@sss.pgh.pa.us 331 :UBC 0 : res = true;
332 : : }
333 : : else
334 : : { /* non-leaf contains signature */
2283 akorotkov@postgresql 335 :CBC 614 : int32 count = cnt_sml_sign_common(qtrg, GETSIGN(key), siglen);
5118 peter_e@gmx.net 336 : 614 : int32 len = ARRNELEM(qtrg);
337 : :
5687 tgl@sss.pgh.pa.us 338 [ - + ]: 614 : if (len == 0)
5687 tgl@sss.pgh.pa.us 339 :UBC 0 : res = false;
340 : : else
3758 teodor@sigaev.ru 341 :CBC 614 : res = (((((float8) count) / ((float8) len))) >= nlimit);
342 : : }
5687 tgl@sss.pgh.pa.us 343 : 35000 : break;
5629 344 : 190 : case ILikeStrategyNumber:
345 : : #ifndef IGNORECASE
346 : : elog(ERROR, "cannot handle ~~* with case-sensitive trigrams");
347 : : #endif
348 : : pg_fallthrough;
349 : : case LikeStrategyNumber:
350 : : case EqualStrategyNumber:
351 : : /* Wildcard and equal search are inexact */
352 : 190 : *recheck = true;
353 : :
354 : : /*
355 : : * Check if all the extracted trigrams can be present in child
356 : : * nodes.
357 : : */
358 [ + - ]: 190 : if (GIST_LEAF(entry))
359 : : { /* all leafs contains orig trgm */
360 : 190 : res = trgm_contained_by(qtrg, key);
361 : : }
5629 tgl@sss.pgh.pa.us 362 [ # # ]:UBC 0 : else if (ISALLTRUE(key))
363 : : { /* non-leaf contains signature */
364 : 0 : res = true;
365 : : }
366 : : else
367 : : { /* non-leaf contains signature */
368 : : int32 k,
5560 bruce@momjian.us 369 : 0 : tmp = 0,
370 : 0 : len = ARRNELEM(qtrg);
371 : 0 : trgm *ptr = GETARR(qtrg);
372 : 0 : BITVECP sign = GETSIGN(key);
373 : :
5629 tgl@sss.pgh.pa.us 374 : 0 : res = true;
375 [ # # ]: 0 : for (k = 0; k < len; k++)
376 : : {
495 peter@eisentraut.org 377 : 0 : CPTRGM(&tmp, ptr + k);
2283 akorotkov@postgresql 378 [ # # ]: 0 : if (!GETBIT(sign, HASHVAL(tmp, siglen)))
379 : : {
5629 tgl@sss.pgh.pa.us 380 : 0 : res = false;
381 : 0 : break;
382 : : }
383 : : }
384 : : }
5629 tgl@sss.pgh.pa.us 385 :CBC 190 : break;
4829 386 : 2216 : case RegExpICaseStrategyNumber:
387 : : #ifndef IGNORECASE
388 : : elog(ERROR, "cannot handle ~* with case-sensitive trigrams");
389 : : #endif
390 : : pg_fallthrough;
391 : : case RegExpStrategyNumber:
392 : : /* Regexp search is inexact */
393 : 2216 : *recheck = true;
394 : :
395 : : /* Check regex match as much as we can with available info */
396 [ + + ]: 2216 : if (qtrg)
397 : : {
398 [ + + ]: 2176 : if (GIST_LEAF(entry))
399 : : { /* all leafs contains orig trgm */
400 : : bool *check;
401 : :
402 : 2150 : check = trgm_presence_map(qtrg, key);
403 : 2150 : res = trigramsMatchGraph(cache->graph, check);
404 : 2150 : pfree(check);
405 : : }
406 [ - + ]: 26 : else if (ISALLTRUE(key))
407 : : { /* non-leaf contains signature */
4829 tgl@sss.pgh.pa.us 408 :UBC 0 : res = true;
409 : : }
410 : : else
411 : : { /* non-leaf contains signature */
412 : : int32 k,
4829 tgl@sss.pgh.pa.us 413 :CBC 26 : tmp = 0,
414 : 26 : len = ARRNELEM(qtrg);
415 : 26 : trgm *ptr = GETARR(qtrg);
416 : 26 : BITVECP sign = GETSIGN(key);
417 : : bool *check;
418 : :
419 : : /*
420 : : * GETBIT() tests may give false positives, due to limited
421 : : * size of the sign array. But since trigramsMatchGraph()
422 : : * implements a monotone boolean function, false positives
423 : : * in the check array can't lead to false negative answer.
424 : : * So we can apply trigramsMatchGraph despite uncertainty,
425 : : * and that usefully improves the quality of the search.
426 : : */
4824 427 : 26 : check = (bool *) palloc(len * sizeof(bool));
4829 428 [ + + ]: 6578 : for (k = 0; k < len; k++)
429 : : {
495 peter@eisentraut.org 430 : 6552 : CPTRGM(&tmp, ptr + k);
2283 akorotkov@postgresql 431 : 6552 : check[k] = GETBIT(sign, HASHVAL(tmp, siglen));
432 : : }
4824 tgl@sss.pgh.pa.us 433 : 26 : res = trigramsMatchGraph(cache->graph, check);
434 : 26 : pfree(check);
435 : : }
436 : : }
437 : : else
438 : : {
439 : : /* trigram-free query must be rechecked everywhere */
4829 440 : 40 : res = true;
441 : : }
442 : 2216 : break;
5687 tgl@sss.pgh.pa.us 443 :UBC 0 : default:
444 [ # # ]: 0 : elog(ERROR, "unrecognized strategy number: %d", strategy);
445 : : res = false; /* keep compiler quiet */
446 : : break;
447 : : }
448 : :
5687 tgl@sss.pgh.pa.us 449 :CBC 37406 : PG_RETURN_BOOL(res);
450 : : }
451 : :
452 : : Datum
453 : 2986 : gtrgm_distance(PG_FUNCTION_ARGS)
454 : : {
455 : 2986 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
456 : 2986 : text *query = PG_GETARG_TEXT_P(1);
457 : 2986 : StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
458 : : #ifdef NOT_USED
459 : : Oid subtype = PG_GETARG_OID(3);
460 : : #endif
3758 teodor@sigaev.ru 461 : 2986 : bool *recheck = (bool *) PG_GETARG_POINTER(4);
2056 akorotkov@postgresql 462 [ + - ]: 2986 : int siglen = GET_SIGLEN();
5687 tgl@sss.pgh.pa.us 463 : 2986 : TRGM *key = (TRGM *) DatumGetPointer(entry->key);
464 : : TRGM *qtrg;
465 : : float8 res;
5387 466 : 2986 : Size querysize = VARSIZE(query);
5687 467 : 2986 : char *cache = (char *) fcinfo->flinfo->fn_extra;
468 : :
469 : : /*
470 : : * Cache the generated trigrams across multiple calls with the same query.
471 : : */
5387 472 [ + + + - ]: 5968 : if (cache == NULL ||
473 [ + - ]: 2982 : VARSIZE(cache) != querysize ||
474 [ - + ]: 2982 : memcmp(cache, query, querysize) != 0)
475 : : {
476 : : char *newcache;
477 : :
478 : 4 : qtrg = generate_trgm(VARDATA(query), querysize - VARHDRSZ);
479 : :
480 : 4 : newcache = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
481 : 4 : MAXALIGN(querysize) +
482 : 4 : VARSIZE(qtrg));
483 : :
484 : 4 : memcpy(newcache, query, querysize);
485 : 4 : memcpy(newcache + MAXALIGN(querysize), qtrg, VARSIZE(qtrg));
486 : :
487 [ - + ]: 4 : if (cache)
5387 tgl@sss.pgh.pa.us 488 :UBC 0 : pfree(cache);
5387 tgl@sss.pgh.pa.us 489 :CBC 4 : fcinfo->flinfo->fn_extra = newcache;
490 : 4 : cache = newcache;
491 : : }
492 : :
493 : 2986 : qtrg = (TRGM *) (cache + MAXALIGN(querysize));
494 : :
5687 495 [ + - ]: 2986 : switch (strategy)
496 : : {
497 : 2986 : case DistanceStrategyNumber:
498 : : case WordDistanceStrategyNumber:
499 : : case StrictWordDistanceStrategyNumber:
500 : : /* Only plain trigram distance is exact */
3023 teodor@sigaev.ru 501 : 2986 : *recheck = (strategy != DistanceStrategyNumber);
5687 tgl@sss.pgh.pa.us 502 [ + + ]: 2986 : if (GIST_LEAF(entry))
503 : : { /* all leafs contains orig trgm */
504 : :
505 : : /*
506 : : * Prevent gcc optimizing the sml variable using volatile
507 : : * keyword. Otherwise res can differ from the
508 : : * word_similarity_dist_op() function.
509 : : */
3758 teodor@sigaev.ru 510 : 2944 : float4 volatile sml = cnt_sml(qtrg, key, *recheck);
511 : :
512 : 2944 : res = 1.0 - sml;
513 : : }
5687 tgl@sss.pgh.pa.us 514 [ - + ]: 42 : else if (ISALLTRUE(key))
515 : : { /* all leafs contains orig trgm */
5687 tgl@sss.pgh.pa.us 516 :UBC 0 : res = 0.0;
517 : : }
518 : : else
519 : : { /* non-leaf contains signature */
2283 akorotkov@postgresql 520 :CBC 42 : int32 count = cnt_sml_sign_common(qtrg, GETSIGN(key), siglen);
5118 peter_e@gmx.net 521 : 42 : int32 len = ARRNELEM(qtrg);
522 : :
5687 tgl@sss.pgh.pa.us 523 [ + - ]: 42 : res = (len == 0) ? -1.0 : 1.0 - ((float8) count) / ((float8) len);
524 : : }
525 : 2986 : break;
5687 tgl@sss.pgh.pa.us 526 :UBC 0 : default:
527 [ # # ]: 0 : elog(ERROR, "unrecognized strategy number: %d", strategy);
528 : : res = 0; /* keep compiler quiet */
529 : : break;
530 : : }
531 : :
5687 tgl@sss.pgh.pa.us 532 :CBC 2986 : PG_RETURN_FLOAT8(res);
533 : : }
534 : :
535 : : static int32
2283 akorotkov@postgresql 536 : 55172 : unionkey(BITVECP sbase, TRGM *add, int siglen)
537 : : {
538 : : int32 i;
539 : :
8065 teodor@sigaev.ru 540 [ + + ]: 55172 : if (ISSIGNKEY(add))
541 : : {
542 : 27586 : BITVECP sadd = GETSIGN(add);
543 : :
544 [ - + ]: 27586 : if (ISALLTRUE(add))
8065 teodor@sigaev.ru 545 :UBC 0 : return 1;
546 : :
2283 akorotkov@postgresql 547 [ + + ]:CBC 6549542 : LOOPBYTE(siglen)
6801 bruce@momjian.us 548 : 6521956 : sbase[i] |= sadd[i];
549 : : }
550 : : else
551 : : {
8065 teodor@sigaev.ru 552 : 27586 : trgm *ptr = GETARR(add);
5118 peter_e@gmx.net 553 : 27586 : int32 tmp = 0;
554 : :
7975 bruce@momjian.us 555 [ + + ]: 275938 : for (i = 0; i < ARRNELEM(add); i++)
556 : : {
495 peter@eisentraut.org 557 : 248352 : CPTRGM(&tmp, ptr + i);
2283 akorotkov@postgresql 558 : 248352 : HASH(sbase, tmp, siglen);
559 : : }
560 : : }
8065 teodor@sigaev.ru 561 : 55172 : return 0;
562 : : }
563 : :
564 : :
565 : : Datum
566 : 27586 : gtrgm_union(PG_FUNCTION_ARGS)
567 : : {
7975 bruce@momjian.us 568 : 27586 : GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
5118 peter_e@gmx.net 569 : 27586 : int32 len = entryvec->n;
8065 teodor@sigaev.ru 570 : 27586 : int *size = (int *) PG_GETARG_POINTER(1);
2056 akorotkov@postgresql 571 [ + - ]: 27586 : int siglen = GET_SIGLEN();
572 : : int32 i;
2283 573 : 27586 : TRGM *result = gtrgm_alloc(false, siglen, NULL);
574 : 27586 : BITVECP base = GETSIGN(result);
575 : :
8065 teodor@sigaev.ru 576 [ + + ]: 82758 : for (i = 0; i < len; i++)
577 : : {
2283 akorotkov@postgresql 578 [ - + ]: 55172 : if (unionkey(base, GETENTRY(entryvec, i), siglen))
579 : : {
2283 akorotkov@postgresql 580 :UBC 0 : result->flag = ALLISTRUE;
581 : 0 : SET_VARSIZE(result, CALCGTSIZE(ALLISTRUE, siglen));
8065 teodor@sigaev.ru 582 : 0 : break;
583 : : }
584 : : }
585 : :
2283 akorotkov@postgresql 586 :CBC 27586 : *size = VARSIZE(result);
587 : :
8065 teodor@sigaev.ru 588 : 27586 : PG_RETURN_POINTER(result);
589 : : }
590 : :
591 : : Datum
592 : 27586 : gtrgm_same(PG_FUNCTION_ARGS)
593 : : {
7975 bruce@momjian.us 594 : 27586 : TRGM *a = (TRGM *) PG_GETARG_POINTER(0);
595 : 27586 : TRGM *b = (TRGM *) PG_GETARG_POINTER(1);
8065 teodor@sigaev.ru 596 : 27586 : bool *result = (bool *) PG_GETARG_POINTER(2);
2056 akorotkov@postgresql 597 [ + - ]: 27586 : int siglen = GET_SIGLEN();
598 : :
8065 teodor@sigaev.ru 599 [ + - ]: 27586 : if (ISSIGNKEY(a))
600 : : { /* then b also ISSIGNKEY */
601 [ - + - - ]: 27586 : if (ISALLTRUE(a) && ISALLTRUE(b))
8065 teodor@sigaev.ru 602 :UBC 0 : *result = true;
8065 teodor@sigaev.ru 603 [ - + ]:CBC 27586 : else if (ISALLTRUE(a))
8065 teodor@sigaev.ru 604 :UBC 0 : *result = false;
8065 teodor@sigaev.ru 605 [ - + ]:CBC 27586 : else if (ISALLTRUE(b))
8065 teodor@sigaev.ru 606 :UBC 0 : *result = false;
607 : : else
608 : : {
609 : : int32 i;
8065 teodor@sigaev.ru 610 :CBC 27586 : BITVECP sa = GETSIGN(a),
611 : 27586 : sb = GETSIGN(b);
612 : :
613 : 27586 : *result = true;
2283 akorotkov@postgresql 614 [ + + ]: 3179501 : LOOPBYTE(siglen)
615 : : {
6801 bruce@momjian.us 616 [ + + ]: 3154738 : if (sa[i] != sb[i])
617 : : {
618 : 2823 : *result = false;
619 : 2823 : break;
620 : : }
621 : : }
622 : : }
623 : : }
624 : : else
625 : : { /* a and b ISARRKEY */
5118 peter_e@gmx.net 626 :UBC 0 : int32 lena = ARRNELEM(a),
8065 teodor@sigaev.ru 627 : 0 : lenb = ARRNELEM(b);
628 : :
629 [ # # ]: 0 : if (lena != lenb)
630 : 0 : *result = false;
631 : : else
632 : : {
633 : 0 : trgm *ptra = GETARR(a),
634 : 0 : *ptrb = GETARR(b);
635 : : int32 i;
636 : :
637 : 0 : *result = true;
638 [ # # ]: 0 : for (i = 0; i < lena; i++)
7975 bruce@momjian.us 639 [ # # ]: 0 : if (CMPTRGM(ptra + i, ptrb + i))
640 : : {
8065 teodor@sigaev.ru 641 : 0 : *result = false;
642 : 0 : break;
643 : : }
644 : : }
645 : : }
646 : :
8065 teodor@sigaev.ru 647 :CBC 27586 : PG_RETURN_POINTER(result);
648 : : }
649 : :
650 : : static int32
2283 akorotkov@postgresql 651 :UBC 0 : sizebitvec(BITVECP sign, int siglen)
652 : : {
653 : 0 : return pg_popcount(sign, siglen);
654 : : }
655 : :
656 : : static int
2283 akorotkov@postgresql 657 :CBC 4922059 : hemdistsign(BITVECP a, BITVECP b, int siglen)
658 : : {
659 : : int i,
660 : : diff,
7975 bruce@momjian.us 661 : 4922059 : dist = 0;
662 : :
2283 akorotkov@postgresql 663 [ + + ]: 369249419 : LOOPBYTE(siglen)
664 : : {
6801 bruce@momjian.us 665 : 364327360 : diff = (unsigned char) (a[i] ^ b[i]);
666 : : /* Using the popcount functions here isn't likely to win */
2692 tgl@sss.pgh.pa.us 667 : 364327360 : dist += pg_number_of_ones[diff];
668 : : }
8065 teodor@sigaev.ru 669 : 4922059 : return dist;
670 : : }
671 : :
672 : : static int
2283 akorotkov@postgresql 673 :UBC 0 : hemdist(TRGM *a, TRGM *b, int siglen)
674 : : {
7975 bruce@momjian.us 675 [ # # ]: 0 : if (ISALLTRUE(a))
676 : : {
8065 teodor@sigaev.ru 677 [ # # ]: 0 : if (ISALLTRUE(b))
678 : 0 : return 0;
679 : : else
2283 akorotkov@postgresql 680 : 0 : return SIGLENBIT(siglen) - sizebitvec(GETSIGN(b), siglen);
681 : : }
7975 bruce@momjian.us 682 [ # # ]: 0 : else if (ISALLTRUE(b))
2283 akorotkov@postgresql 683 : 0 : return SIGLENBIT(siglen) - sizebitvec(GETSIGN(a), siglen);
684 : :
685 : 0 : return hemdistsign(GETSIGN(a), GETSIGN(b), siglen);
686 : : }
687 : :
688 : : Datum
8065 teodor@sigaev.ru 689 :CBC 1185972 : gtrgm_penalty(PG_FUNCTION_ARGS)
690 : : {
691 : 1185972 : GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
692 : 1185972 : GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
693 : 1185972 : float *penalty = (float *) PG_GETARG_POINTER(2);
2056 akorotkov@postgresql 694 [ + - ]: 1185972 : int siglen = GET_SIGLEN();
7975 bruce@momjian.us 695 : 1185972 : TRGM *origval = (TRGM *) DatumGetPointer(origentry->key);
696 : 1185972 : TRGM *newval = (TRGM *) DatumGetPointer(newentry->key);
8065 teodor@sigaev.ru 697 : 1185972 : BITVECP orig = GETSIGN(origval);
698 : :
699 : 1185972 : *penalty = 0.0;
700 : :
7975 bruce@momjian.us 701 [ + - ]: 1185972 : if (ISARRKEY(newval))
702 : : {
5387 tgl@sss.pgh.pa.us 703 : 1185972 : char *cache = (char *) fcinfo->flinfo->fn_extra;
146 john.naylor@postgres 704 : 1185972 : TRGM *cachedVal = NULL;
5387 tgl@sss.pgh.pa.us 705 : 1185972 : Size newvalsize = VARSIZE(newval);
706 : : BITVECP sign;
707 : :
146 john.naylor@postgres 708 [ + + ]: 1185972 : if (cache != NULL)
709 : 1185966 : cachedVal = (TRGM *) (cache + MAXALIGN(siglen));
710 : :
711 : : /*
712 : : * Cache the sign data across multiple calls with the same newval.
713 : : */
5387 tgl@sss.pgh.pa.us 714 [ + + + + ]: 2371938 : if (cache == NULL ||
715 [ + + ]: 1185966 : VARSIZE(cachedVal) != newvalsize ||
716 [ + + ]: 1184939 : memcmp(cachedVal, newval, newvalsize) != 0)
717 : : {
718 : : char *newcache;
719 : :
720 : 3763 : newcache = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
2283 akorotkov@postgresql 721 : 3763 : MAXALIGN(siglen) +
722 : : newvalsize);
723 : :
724 : 3763 : makesign((BITVECP) newcache, newval, siglen);
725 : :
726 : 3763 : cachedVal = (TRGM *) (newcache + MAXALIGN(siglen));
5387 tgl@sss.pgh.pa.us 727 : 3763 : memcpy(cachedVal, newval, newvalsize);
728 : :
729 [ + + ]: 3763 : if (cache)
730 : 3757 : pfree(cache);
731 : 3763 : fcinfo->flinfo->fn_extra = newcache;
732 : 3763 : cache = newcache;
733 : : }
734 : :
735 : 1185972 : sign = (BITVECP) cache;
736 : :
7975 bruce@momjian.us 737 [ - + ]: 1185972 : if (ISALLTRUE(origval))
2283 akorotkov@postgresql 738 :UBC 0 : *penalty = ((float) (SIGLENBIT(siglen) - sizebitvec(sign, siglen))) / (float) (SIGLENBIT(siglen) + 1);
739 : : else
2283 akorotkov@postgresql 740 :CBC 1185972 : *penalty = hemdistsign(sign, orig, siglen);
741 : : }
742 : : else
2283 akorotkov@postgresql 743 :UBC 0 : *penalty = hemdist(origval, newval, siglen);
8065 teodor@sigaev.ru 744 :CBC 1185972 : PG_RETURN_POINTER(penalty);
745 : : }
746 : :
747 : : typedef struct
748 : : {
749 : : bool allistrue;
750 : : BITVECP sign;
751 : : } CACHESIGN;
752 : :
753 : : static void
2283 akorotkov@postgresql 754 : 44205 : fillcache(CACHESIGN *item, TRGM *key, BITVECP sign, int siglen)
755 : : {
8065 teodor@sigaev.ru 756 : 44205 : item->allistrue = false;
2283 akorotkov@postgresql 757 : 44205 : item->sign = sign;
8065 teodor@sigaev.ru 758 [ + + ]: 44205 : if (ISARRKEY(key))
2283 akorotkov@postgresql 759 : 43969 : makesign(item->sign, key, siglen);
8065 teodor@sigaev.ru 760 [ - + ]: 236 : else if (ISALLTRUE(key))
8065 teodor@sigaev.ru 761 :UBC 0 : item->allistrue = true;
762 : : else
1239 peter@eisentraut.org 763 :CBC 236 : memcpy(item->sign, GETSIGN(key), siglen);
8065 teodor@sigaev.ru 764 : 44205 : }
765 : :
766 : : #define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
767 : : typedef struct
768 : : {
769 : : OffsetNumber pos;
770 : : int32 cost;
771 : : } SPLITCOST;
772 : :
773 : : static int
774 : 49287 : comparecost(const void *a, const void *b)
775 : : {
5406 peter_e@gmx.net 776 [ + + ]: 49287 : if (((const SPLITCOST *) a)->cost == ((const SPLITCOST *) b)->cost)
8065 teodor@sigaev.ru 777 : 44313 : return 0;
778 : : else
5406 peter_e@gmx.net 779 [ + + ]: 4974 : return (((const SPLITCOST *) a)->cost > ((const SPLITCOST *) b)->cost) ? 1 : -1;
780 : : }
781 : :
782 : :
783 : : static int
2283 akorotkov@postgresql 784 : 3648809 : hemdistcache(CACHESIGN *a, CACHESIGN *b, int siglen)
785 : : {
7975 bruce@momjian.us 786 [ - + ]: 3648809 : if (a->allistrue)
787 : : {
8065 teodor@sigaev.ru 788 [ # # ]:UBC 0 : if (b->allistrue)
789 : 0 : return 0;
790 : : else
2283 akorotkov@postgresql 791 : 0 : return SIGLENBIT(siglen) - sizebitvec(b->sign, siglen);
792 : : }
7975 bruce@momjian.us 793 [ - + ]:CBC 3648809 : else if (b->allistrue)
2283 akorotkov@postgresql 794 :UBC 0 : return SIGLENBIT(siglen) - sizebitvec(a->sign, siglen);
795 : :
2283 akorotkov@postgresql 796 :CBC 3648809 : return hemdistsign(a->sign, b->sign, siglen);
797 : : }
798 : :
799 : : Datum
8065 teodor@sigaev.ru 800 : 283 : gtrgm_picksplit(PG_FUNCTION_ARGS)
801 : : {
7975 bruce@momjian.us 802 : 283 : GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
2056 rhodiumtoad@postgres 803 : 283 : OffsetNumber maxoff = entryvec->n - 1;
8065 teodor@sigaev.ru 804 : 283 : GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
2056 akorotkov@postgresql 805 [ + - ]: 283 : int siglen = GET_SIGLEN();
806 : : OffsetNumber k,
807 : : j;
808 : : TRGM *datum_l,
809 : : *datum_r;
810 : : BITVECP union_l,
811 : : union_r;
812 : : int32 size_alpha,
813 : : size_beta;
814 : : int32 size_waste,
8065 teodor@sigaev.ru 815 : 283 : waste = -1;
816 : : int32 nbytes;
817 : 283 : OffsetNumber seed_1 = 0,
818 : 283 : seed_2 = 0;
819 : : OffsetNumber *left,
820 : : *right;
821 : : BITVECP ptr;
822 : : int i;
823 : : CACHESIGN *cache;
824 : : char *cache_sign;
825 : : SPLITCOST *costvector;
826 : :
827 : : /* cache the sign data for each existing item */
207 michael@paquier.xyz 828 :GNC 283 : cache = palloc_array(CACHESIGN, maxoff + 1);
2056 rhodiumtoad@postgres 829 :CBC 283 : cache_sign = palloc(siglen * (maxoff + 1));
830 : :
5387 tgl@sss.pgh.pa.us 831 [ + + ]: 44488 : for (k = FirstOffsetNumber; k <= maxoff; k = OffsetNumberNext(k))
2283 akorotkov@postgresql 832 : 44205 : fillcache(&cache[k], GETENTRY(entryvec, k), &cache_sign[siglen * k],
833 : : siglen);
834 : :
835 : : /* now find the two furthest-apart items */
7975 bruce@momjian.us 836 [ + + ]: 44205 : for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
837 : : {
838 [ + + ]: 3604321 : for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
839 : : {
2283 akorotkov@postgresql 840 : 3560399 : size_waste = hemdistcache(&(cache[j]), &(cache[k]), siglen);
7975 bruce@momjian.us 841 [ + + ]: 3560399 : if (size_waste > waste)
842 : : {
8065 teodor@sigaev.ru 843 : 470 : waste = size_waste;
844 : 470 : seed_1 = k;
845 : 470 : seed_2 = j;
846 : : }
847 : : }
848 : : }
849 : :
850 : : /* just in case we didn't make a selection ... */
7975 bruce@momjian.us 851 [ + - - + ]: 283 : if (seed_1 == 0 || seed_2 == 0)
852 : : {
8065 teodor@sigaev.ru 853 :UBC 0 : seed_1 = 1;
854 : 0 : seed_2 = 2;
855 : : }
856 : :
857 : : /* initialize the result vectors */
2056 rhodiumtoad@postgres 858 :CBC 283 : nbytes = maxoff * sizeof(OffsetNumber);
5387 tgl@sss.pgh.pa.us 859 : 283 : v->spl_left = left = (OffsetNumber *) palloc(nbytes);
860 : 283 : v->spl_right = right = (OffsetNumber *) palloc(nbytes);
861 : 283 : v->spl_nleft = 0;
862 : 283 : v->spl_nright = 0;
863 : :
864 : : /* form initial .. */
2283 akorotkov@postgresql 865 : 283 : datum_l = gtrgm_alloc(cache[seed_1].allistrue, siglen, cache[seed_1].sign);
866 : 283 : datum_r = gtrgm_alloc(cache[seed_2].allistrue, siglen, cache[seed_2].sign);
867 : :
7975 bruce@momjian.us 868 : 283 : union_l = GETSIGN(datum_l);
869 : 283 : union_r = GETSIGN(datum_r);
870 : :
871 : : /* sort before ... */
207 michael@paquier.xyz 872 :GNC 283 : costvector = palloc_array(SPLITCOST, maxoff);
7975 bruce@momjian.us 873 [ + + ]:CBC 44488 : for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
874 : : {
8065 teodor@sigaev.ru 875 : 44205 : costvector[j - 1].pos = j;
2283 akorotkov@postgresql 876 : 44205 : size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]), siglen);
877 : 44205 : size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
8065 teodor@sigaev.ru 878 : 44205 : costvector[j - 1].cost = abs(size_alpha - size_beta);
879 : : }
1239 peter@eisentraut.org 880 : 283 : qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
881 : :
7975 bruce@momjian.us 882 [ + + ]: 44488 : for (k = 0; k < maxoff; k++)
883 : : {
8065 teodor@sigaev.ru 884 : 44205 : j = costvector[k].pos;
7975 bruce@momjian.us 885 [ + + ]: 44205 : if (j == seed_1)
886 : : {
8065 teodor@sigaev.ru 887 : 283 : *left++ = j;
888 : 283 : v->spl_nleft++;
889 : 283 : continue;
890 : : }
7975 bruce@momjian.us 891 [ + + ]: 43922 : else if (j == seed_2)
892 : : {
8065 teodor@sigaev.ru 893 : 283 : *right++ = j;
894 : 283 : v->spl_nright++;
895 : 283 : continue;
896 : : }
897 : :
7975 bruce@momjian.us 898 [ + - - + ]: 43639 : if (ISALLTRUE(datum_l) || cache[j].allistrue)
899 : : {
7975 bruce@momjian.us 900 [ # # # # ]:UBC 0 : if (ISALLTRUE(datum_l) && cache[j].allistrue)
901 : 0 : size_alpha = 0;
902 : : else
2283 akorotkov@postgresql 903 : 0 : size_alpha = SIGLENBIT(siglen) -
2343 alvherre@alvh.no-ip. 904 [ # # ]: 0 : sizebitvec((cache[j].allistrue) ? GETSIGN(datum_l) :
2283 akorotkov@postgresql 905 : 0 : GETSIGN(cache[j].sign),
906 : : siglen);
907 : : }
908 : : else
2283 akorotkov@postgresql 909 :CBC 43639 : size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l), siglen);
910 : :
7975 bruce@momjian.us 911 [ + - - + ]: 43639 : if (ISALLTRUE(datum_r) || cache[j].allistrue)
912 : : {
7975 bruce@momjian.us 913 [ # # # # ]:UBC 0 : if (ISALLTRUE(datum_r) && cache[j].allistrue)
914 : 0 : size_beta = 0;
915 : : else
2283 akorotkov@postgresql 916 : 0 : size_beta = SIGLENBIT(siglen) -
2343 alvherre@alvh.no-ip. 917 [ # # ]: 0 : sizebitvec((cache[j].allistrue) ? GETSIGN(datum_r) :
2283 akorotkov@postgresql 918 : 0 : GETSIGN(cache[j].sign),
919 : : siglen);
920 : : }
921 : : else
2283 akorotkov@postgresql 922 :CBC 43639 : size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r), siglen);
923 : :
7975 bruce@momjian.us 924 [ + + ]: 43639 : if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1))
925 : : {
926 [ + - - + ]: 21699 : if (ISALLTRUE(datum_l) || cache[j].allistrue)
927 : : {
7975 bruce@momjian.us 928 [ # # ]:UBC 0 : if (!ISALLTRUE(datum_l))
1239 peter@eisentraut.org 929 : 0 : memset(GETSIGN(datum_l), 0xff, siglen);
930 : : }
931 : : else
932 : : {
7975 bruce@momjian.us 933 :CBC 21699 : ptr = cache[j].sign;
2283 akorotkov@postgresql 934 [ + + ]: 2493275 : LOOPBYTE(siglen)
6801 bruce@momjian.us 935 : 2471576 : union_l[i] |= ptr[i];
936 : : }
8065 teodor@sigaev.ru 937 : 21699 : *left++ = j;
938 : 21699 : v->spl_nleft++;
939 : : }
940 : : else
941 : : {
7975 bruce@momjian.us 942 [ + - - + ]: 21940 : if (ISALLTRUE(datum_r) || cache[j].allistrue)
943 : : {
7975 bruce@momjian.us 944 [ # # ]:UBC 0 : if (!ISALLTRUE(datum_r))
1239 peter@eisentraut.org 945 : 0 : memset(GETSIGN(datum_r), 0xff, siglen);
946 : : }
947 : : else
948 : : {
7975 bruce@momjian.us 949 :CBC 21940 : ptr = cache[j].sign;
2283 akorotkov@postgresql 950 [ + + ]: 2488360 : LOOPBYTE(siglen)
6801 bruce@momjian.us 951 : 2466420 : union_r[i] |= ptr[i];
952 : : }
8065 teodor@sigaev.ru 953 : 21940 : *right++ = j;
954 : 21940 : v->spl_nright++;
955 : : }
956 : : }
957 : :
958 : 283 : v->spl_ldatum = PointerGetDatum(datum_l);
959 : 283 : v->spl_rdatum = PointerGetDatum(datum_r);
960 : :
961 : 283 : PG_RETURN_POINTER(v);
962 : : }
963 : :
964 : : Datum
2283 akorotkov@postgresql 965 : 31 : gtrgm_options(PG_FUNCTION_ARGS)
966 : : {
967 : 31 : local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
968 : :
969 : 31 : init_local_reloptions(relopts, sizeof(TrgmGistOptions));
970 : 31 : add_local_int_reloption(relopts, "siglen",
971 : : "signature length in bytes",
972 : : SIGLEN_DEFAULT, 1, SIGLEN_MAX,
973 : : offsetof(TrgmGistOptions, siglen));
974 : :
975 : 31 : PG_RETURN_VOID();
976 : : }
|
