?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Start background writer during archive recovery. Background writer now performs
[PostgreSQL.git] / contrib / ltree / ltree_gist.c
blob9c9e997741ae2b71e69a8d2fd19a716319444bc7
1 /*
2 * GiST support for ltree
3 * Teodor Sigaev <teodor@stack.net>
4 * $PostgreSQL$
5 */
6 #include "postgres.h"
7
8 #include "access/gist.h"
9 #include "access/nbtree.h"
10 #include "access/skey.h"
11 #include "utils/array.h"
12 #include "crc32.h"
13 #include "ltree.h"
14
15 #define NEXTVAL(x) ( (lquery*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
16
17 PG_FUNCTION_INFO_V1(ltree_gist_in);
18 Datum ltree_gist_in(PG_FUNCTION_ARGS);
19
20 PG_FUNCTION_INFO_V1(ltree_gist_out);
21 Datum ltree_gist_out(PG_FUNCTION_ARGS);
22
23 Datum
24 ltree_gist_in(PG_FUNCTION_ARGS)
25 {
26 ereport(ERROR,
27 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
28 errmsg("ltree_gist_in() not implemented")));
29 PG_RETURN_DATUM(0);
30 }
31
32 Datum
33 ltree_gist_out(PG_FUNCTION_ARGS)
34 {
35 ereport(ERROR,
36 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
37 errmsg("ltree_gist_out() not implemented")));
38 PG_RETURN_DATUM(0);
39 }
40
41 PG_FUNCTION_INFO_V1(ltree_compress);
42 Datum ltree_compress(PG_FUNCTION_ARGS);
43
44 PG_FUNCTION_INFO_V1(ltree_decompress);
45 Datum ltree_decompress(PG_FUNCTION_ARGS);
46
47 PG_FUNCTION_INFO_V1(ltree_same);
48 Datum ltree_same(PG_FUNCTION_ARGS);
49
50 PG_FUNCTION_INFO_V1(ltree_union);
51 Datum ltree_union(PG_FUNCTION_ARGS);
52
53 PG_FUNCTION_INFO_V1(ltree_penalty);
54 Datum ltree_penalty(PG_FUNCTION_ARGS);
55
56 PG_FUNCTION_INFO_V1(ltree_picksplit);
57 Datum ltree_picksplit(PG_FUNCTION_ARGS);
58
59 PG_FUNCTION_INFO_V1(ltree_consistent);
60 Datum ltree_consistent(PG_FUNCTION_ARGS);
61
62 #define ISEQ(a,b) ( (a)->numlevel == (b)->numlevel && ltree_compare(a,b)==0 )
63 #define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer((vec)->vector[(pos)].key))
64
65 Datum
66 ltree_compress(PG_FUNCTION_ARGS)
67 {
68 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
69 GISTENTRY *retval = entry;
70
71 if (entry->leafkey)
72 { /* ltree */
73 ltree_gist *key;
74 ltree *val = (ltree *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
75 int4 len = LTG_HDRSIZE + VARSIZE(val);
76
77 key = (ltree_gist *) palloc(len);
78 SET_VARSIZE(key, len);
79 key->flag = LTG_ONENODE;
80 memcpy((void *) LTG_NODE(key), (void *) val, VARSIZE(val));
81
82 retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
83 gistentryinit(*retval, PointerGetDatum(key),
84 entry->rel, entry->page,
85 entry->offset, FALSE);
86 }
87 PG_RETURN_POINTER(retval);
88 }
89
90 Datum
91 ltree_decompress(PG_FUNCTION_ARGS)
92 {
93 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
94 ltree_gist *key = (ltree_gist *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
95
96 if (PointerGetDatum(key) != entry->key)
97 {
98 GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
99
100 gistentryinit(*retval, PointerGetDatum(key),
101 entry->rel, entry->page,
102 entry->offset, FALSE);
103 PG_RETURN_POINTER(retval);
104 }
105 PG_RETURN_POINTER(entry);
106 }
107
108 Datum
109 ltree_same(PG_FUNCTION_ARGS)
110 {
111 ltree_gist *a = (ltree_gist *) PG_GETARG_POINTER(0);
112 ltree_gist *b = (ltree_gist *) PG_GETARG_POINTER(1);
113 bool *result = (bool *) PG_GETARG_POINTER(2);
114
115 *result = false;
116 if (LTG_ISONENODE(a) != LTG_ISONENODE(b))
117 PG_RETURN_POINTER(result);
118
119 if (LTG_ISONENODE(a))
120 *result = (ISEQ(LTG_NODE(a), LTG_NODE(b))) ? true : false;
121 else
122 {
123 int4 i;
124 BITVECP sa = LTG_SIGN(a),
125 sb = LTG_SIGN(b);
126
127 if (LTG_ISALLTRUE(a) != LTG_ISALLTRUE(b))
128 PG_RETURN_POINTER(result);
129
130 if (!ISEQ(LTG_LNODE(a), LTG_LNODE(b)))
131 PG_RETURN_POINTER(result);
132 if (!ISEQ(LTG_RNODE(a), LTG_RNODE(b)))
133 PG_RETURN_POINTER(result);
134
135 *result = true;
136 if (!LTG_ISALLTRUE(a))
137 {
138 LOOPBYTE
139 {
140 if (sa[i] != sb[i])
141 {
142 *result = false;
143 break;
144 }
145 }
146 }
147 }
148
149 PG_RETURN_POINTER(result);
150 }
151
152 static void
153 hashing(BITVECP sign, ltree * t)
154 {
155 int tlen = t->numlevel;
156 ltree_level *cur = LTREE_FIRST(t);
157 int hash;
158
159 while (tlen > 0)
160 {
161 hash = ltree_crc32_sz(cur->name, cur->len);
162 HASH(sign, hash);
163 cur = LEVEL_NEXT(cur);
164 tlen--;
165 }
166 }
167
168 Datum
169 ltree_union(PG_FUNCTION_ARGS)
170 {
171 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
172 int *size = (int *) PG_GETARG_POINTER(1);
173 BITVEC base;
174 int4 i,
175 j;
176 ltree_gist *result,
177 *cur;
178 ltree *left = NULL,
179 *right = NULL,
180 *curtree;
181 bool isalltrue = false;
182 bool isleqr;
183
184 MemSet((void *) base, 0, sizeof(BITVEC));
185 for (j = 0; j < entryvec->n; j++)
186 {
187 cur = GETENTRY(entryvec, j);
188 if (LTG_ISONENODE(cur))
189 {
190 curtree = LTG_NODE(cur);
191 hashing(base, curtree);
192 if (!left || ltree_compare(left, curtree) > 0)
193 left = curtree;
194 if (!right || ltree_compare(right, curtree) < 0)
195 right = curtree;
196 }
197 else
198 {
199 if (isalltrue || LTG_ISALLTRUE(cur))
200 isalltrue = true;
201 else
202 {
203 BITVECP sc = LTG_SIGN(cur);
204
205 LOOPBYTE
206 ((unsigned char *) base)[i] |= sc[i];
207 }
208
209 curtree = LTG_LNODE(cur);
210 if (!left || ltree_compare(left, curtree) > 0)
211 left = curtree;
212 curtree = LTG_RNODE(cur);
213 if (!right || ltree_compare(right, curtree) < 0)
214 right = curtree;
215 }
216 }
217
218 if (isalltrue == false)
219 {
220 isalltrue = true;
221 LOOPBYTE
222 {
223 if (((unsigned char *) base)[i] != 0xff)
224 {
225 isalltrue = false;
226 break;
227 }
228 }
229 }
230
231 isleqr = (left == right || ISEQ(left, right)) ? true : false;
232 *size = LTG_HDRSIZE + ((isalltrue) ? 0 : SIGLEN) + VARSIZE(left) + ((isleqr) ? 0 : VARSIZE(right));
233
234 result = (ltree_gist *) palloc(*size);
235 SET_VARSIZE(result, *size);
236 result->flag = 0;
237
238 if (isalltrue)
239 result->flag |= LTG_ALLTRUE;
240 else
241 memcpy((void *) LTG_SIGN(result), base, SIGLEN);
242
243 memcpy((void *) LTG_LNODE(result), (void *) left, VARSIZE(left));
244 if (isleqr)
245 result->flag |= LTG_NORIGHT;
246 else
247 memcpy((void *) LTG_RNODE(result), (void *) right, VARSIZE(right));
248
249 PG_RETURN_POINTER(result);
250 }
251
252 Datum
253 ltree_penalty(PG_FUNCTION_ARGS)
254 {
255 ltree_gist *origval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
256 ltree_gist *newval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
257 float *penalty = (float *) PG_GETARG_POINTER(2);
258 int4 cmpr,
259 cmpl;
260
261 cmpl = ltree_compare(LTG_GETLNODE(origval), LTG_GETLNODE(newval));
262 cmpr = ltree_compare(LTG_GETRNODE(newval), LTG_GETRNODE(origval));
263
264 *penalty = Max(cmpl, 0) + Max(cmpr, 0);
265
266 PG_RETURN_POINTER(penalty);
267 }
268
269 /* used for sorting */
270 typedef struct rix
271 {
272 int index;
273 ltree *r;
274 } RIX;
275
276 static int
277 treekey_cmp(const void *a, const void *b)
278 {
279 return ltree_compare(
280 ((RIX *) a)->r,
281 ((RIX *) b)->r
282 );
283 }
284
285
286 Datum
287 ltree_picksplit(PG_FUNCTION_ARGS)
288 {
289 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
290 GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
291 OffsetNumber j;
292 int4 i;
293 RIX *array;
294 OffsetNumber maxoff;
295 int nbytes;
296 int size;
297 ltree *lu_l,
298 *lu_r,
299 *ru_l,
300 *ru_r;
301 ltree_gist *lu,
302 *ru;
303 BITVEC ls,
304 rs;
305 bool lisat = false,
306 risat = false,
307 isleqr;
308
309 memset((void *) ls, 0, sizeof(BITVEC));
310 memset((void *) rs, 0, sizeof(BITVEC));
311 maxoff = entryvec->n - 1;
312 nbytes = (maxoff + 2) * sizeof(OffsetNumber);
313 v->spl_left = (OffsetNumber *) palloc(nbytes);
314 v->spl_right = (OffsetNumber *) palloc(nbytes);
315 v->spl_nleft = 0;
316 v->spl_nright = 0;
317 array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
318
319 /* copy the data into RIXes, and sort the RIXes */
320 for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
321 {
322 array[j].index = j;
323 lu = GETENTRY(entryvec, j); /* use as tmp val */
324 array[j].r = LTG_GETLNODE(lu);
325 }
326
327 qsort((void *) &array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
328 sizeof(RIX), treekey_cmp);
329
330 lu_l = lu_r = ru_l = ru_r = NULL;
331 for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
332 {
333 lu = GETENTRY(entryvec, array[j].index); /* use as tmp val */
334 if (j <= (maxoff - FirstOffsetNumber + 1) / 2)
335 {
336 v->spl_left[v->spl_nleft] = array[j].index;
337 v->spl_nleft++;
338 if (lu_r == NULL || ltree_compare(LTG_GETRNODE(lu), lu_r) > 0)
339 lu_r = LTG_GETRNODE(lu);
340 if (LTG_ISONENODE(lu))
341 hashing(ls, LTG_NODE(lu));
342 else
343 {
344 if (lisat || LTG_ISALLTRUE(lu))
345 lisat = true;
346 else
347 {
348 BITVECP sc = LTG_SIGN(lu);
349
350 LOOPBYTE
351 ((unsigned char *) ls)[i] |= sc[i];
352 }
353 }
354 }
355 else
356 {
357 v->spl_right[v->spl_nright] = array[j].index;
358 v->spl_nright++;
359 if (ru_r == NULL || ltree_compare(LTG_GETRNODE(lu), ru_r) > 0)
360 ru_r = LTG_GETRNODE(lu);
361 if (LTG_ISONENODE(lu))
362 hashing(rs, LTG_NODE(lu));
363 else
364 {
365 if (risat || LTG_ISALLTRUE(lu))
366 risat = true;
367 else
368 {
369 BITVECP sc = LTG_SIGN(lu);
370
371 LOOPBYTE
372 ((unsigned char *) rs)[i] |= sc[i];
373 }
374 }
375 }
376 }
377
378 if (lisat == false)
379 {
380 lisat = true;
381 LOOPBYTE
382 {
383 if (((unsigned char *) ls)[i] != 0xff)
384 {
385 lisat = false;
386 break;
387 }
388 }
389 }
390
391 if (risat == false)
392 {
393 risat = true;
394 LOOPBYTE
395 {
396 if (((unsigned char *) rs)[i] != 0xff)
397 {
398 risat = false;
399 break;
400 }
401 }
402 }
403
404 lu_l = LTG_GETLNODE(GETENTRY(entryvec, array[FirstOffsetNumber].index));
405 isleqr = (lu_l == lu_r || ISEQ(lu_l, lu_r)) ? true : false;
406 size = LTG_HDRSIZE + ((lisat) ? 0 : SIGLEN) + VARSIZE(lu_l) + ((isleqr) ? 0 : VARSIZE(lu_r));
407 lu = (ltree_gist *) palloc(size);
408 SET_VARSIZE(lu, size);
409 lu->flag = 0;
410 if (lisat)
411 lu->flag |= LTG_ALLTRUE;
412 else
413 memcpy((void *) LTG_SIGN(lu), ls, SIGLEN);
414 memcpy((void *) LTG_LNODE(lu), (void *) lu_l, VARSIZE(lu_l));
415 if (isleqr)
416 lu->flag |= LTG_NORIGHT;
417 else
418 memcpy((void *) LTG_RNODE(lu), (void *) lu_r, VARSIZE(lu_r));
419
420
421 ru_l = LTG_GETLNODE(GETENTRY(entryvec, array[1 + ((maxoff - FirstOffsetNumber + 1) / 2)].index));
422 isleqr = (ru_l == ru_r || ISEQ(ru_l, ru_r)) ? true : false;
423 size = LTG_HDRSIZE + ((risat) ? 0 : SIGLEN) + VARSIZE(ru_l) + ((isleqr) ? 0 : VARSIZE(ru_r));
424 ru = (ltree_gist *) palloc(size);
425 SET_VARSIZE(ru, size);
426 ru->flag = 0;
427 if (risat)
428 ru->flag |= LTG_ALLTRUE;
429 else
430 memcpy((void *) LTG_SIGN(ru), rs, SIGLEN);
431 memcpy((void *) LTG_LNODE(ru), (void *) ru_l, VARSIZE(ru_l));
432 if (isleqr)
433 ru->flag |= LTG_NORIGHT;
434 else
435 memcpy((void *) LTG_RNODE(ru), (void *) ru_r, VARSIZE(ru_r));
436
437 v->spl_ldatum = PointerGetDatum(lu);
438 v->spl_rdatum = PointerGetDatum(ru);
439
440 PG_RETURN_POINTER(v);
441 }
442
443 static bool
444 gist_isparent(ltree_gist * key, ltree * query)
445 {
446 int4 numlevel = query->numlevel;
447 int i;
448
449 for (i = query->numlevel; i >= 0; i--)
450 {
451 query->numlevel = i;
452 if (ltree_compare(query, LTG_GETLNODE(key)) >= 0 && ltree_compare(query, LTG_GETRNODE(key)) <= 0)
453 {
454 query->numlevel = numlevel;
455 return true;
456 }
457 }
458
459 query->numlevel = numlevel;
460 return false;
461 }
462
463 static ltree *
464 copy_ltree(ltree * src)
465 {
466 ltree *dst = (ltree *) palloc(VARSIZE(src));
467
468 memcpy(dst, src, VARSIZE(src));
469 return dst;
470 }
471
472 static bool
473 gist_ischild(ltree_gist * key, ltree * query)
474 {
475 ltree *left = copy_ltree(LTG_GETLNODE(key));
476 ltree *right = copy_ltree(LTG_GETRNODE(key));
477 bool res = true;
478
479 if (left->numlevel > query->numlevel)
480 left->numlevel = query->numlevel;
481
482 if (ltree_compare(query, left) < 0)
483 res = false;
484
485 if (right->numlevel > query->numlevel)
486 right->numlevel = query->numlevel;
487
488 if (res && ltree_compare(query, right) > 0)
489 res = false;
490
491 pfree(left);
492 pfree(right);
493
494 return res;
495 }
496
497 static bool
498 gist_qe(ltree_gist * key, lquery * query)
499 {
500 lquery_level *curq = LQUERY_FIRST(query);
501 BITVECP sign = LTG_SIGN(key);
502 int qlen = query->numlevel;
503
504 if (LTG_ISALLTRUE(key))
505 return true;
506
507 while (qlen > 0)
508 {
509 if (curq->numvar && LQL_CANLOOKSIGN(curq))
510 {
511 bool isexist = false;
512 int vlen = curq->numvar;
513 lquery_variant *curv = LQL_FIRST(curq);
514
515 while (vlen > 0)
516 {
517 if (GETBIT(sign, HASHVAL(curv->val)))
518 {
519 isexist = true;
520 break;
521 }
522 curv = LVAR_NEXT(curv);
523 vlen--;
524 }
525 if (!isexist)
526 return false;
527 }
528
529 curq = LQL_NEXT(curq);
530 qlen--;
531 }
532
533 return true;
534 }
535
536 static int
537 gist_tqcmp(ltree * t, lquery * q)
538 {
539 ltree_level *al = LTREE_FIRST(t);
540 lquery_level *ql = LQUERY_FIRST(q);
541 lquery_variant *bl;
542 int an = t->numlevel;
543 int bn = q->firstgood;
544 int res = 0;
545
546 while (an > 0 && bn > 0)
547 {
548 bl = LQL_FIRST(ql);
549 if ((res = strncmp(al->name, bl->name, Min(al->len, bl->len))) == 0)
550 {
551 if (al->len != bl->len)
552 return al->len - bl->len;
553 }
554 else
555 return res;
556 an--;
557 bn--;
558 al = LEVEL_NEXT(al);
559 ql = LQL_NEXT(ql);
560 }
561
562 return Min(t->numlevel, q->firstgood) - q->firstgood;
563 }
564
565 static bool
566 gist_between(ltree_gist * key, lquery * query)
567 {
568 if (query->firstgood == 0)
569 return true;
570
571 if (gist_tqcmp(LTG_GETLNODE(key), query) > 0)
572 return false;
573
574 if (gist_tqcmp(LTG_GETRNODE(key), query) < 0)
575 return false;
576
577 return true;
578 }
579
580 static bool
581 checkcondition_bit(void *checkval, ITEM * val)
582 {
583 return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(checkval, HASHVAL(val->val)) : true;
584 }
585
586 static bool
587 gist_qtxt(ltree_gist * key, ltxtquery * query)
588 {
589 if (LTG_ISALLTRUE(key))
590 return true;
591
592 return ltree_execute(
593 GETQUERY(query),
594 (void *) LTG_SIGN(key), false,
595 checkcondition_bit
596 );
597 }
598
599 static bool
600 arrq_cons(ltree_gist * key, ArrayType *_query)
601 {
602 lquery *query = (lquery *) ARR_DATA_PTR(_query);
603 int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
604
605 if (ARR_NDIM(_query) != 1)
606 ereport(ERROR,
607 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
608 errmsg("array must be one-dimensional")));
609 if (ARR_HASNULL(_query))
610 ereport(ERROR,
611 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
612 errmsg("array must not contain nulls")));
613
614 while (num > 0)
615 {
616 if (gist_qe(key, query) && gist_between(key, query))
617 return true;
618 num--;
619 query = NEXTVAL(query);
620 }
621 return false;
622 }
623
624 Datum
625 ltree_consistent(PG_FUNCTION_ARGS)
626 {
627 GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
628 StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
629 /* Oid subtype = PG_GETARG_OID(3); */
630 bool *recheck = (bool *) PG_GETARG_POINTER(4);
631 ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
632 void *query = NULL;
633 bool res = false;
634
635 /* All cases served by this function are exact */
636 *recheck = false;
637
638 switch (strategy)
639 {
640 case BTLessStrategyNumber:
641 query = PG_GETARG_LTREE(1);
642 res = (GIST_LEAF(entry)) ?
643 (ltree_compare((ltree *) query, LTG_NODE(key)) > 0)
644 :
645 (ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0);
646 break;
647 case BTLessEqualStrategyNumber:
648 query = PG_GETARG_LTREE(1);
649 res = (ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0);
650 break;
651 case BTEqualStrategyNumber:
652 query = PG_GETARG_LTREE(1);
653 if (GIST_LEAF(entry))
654 res = (ltree_compare((ltree *) query, LTG_NODE(key)) == 0);
655 else
656 res = (
657 ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0
658 &&
659 ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0
660 );
661 break;
662 case BTGreaterEqualStrategyNumber:
663 query = PG_GETARG_LTREE(1);
664 res = (ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0);
665 break;
666 case BTGreaterStrategyNumber:
667 query = PG_GETARG_LTREE(1);
668 res = (GIST_LEAF(entry)) ?
669 (ltree_compare((ltree *) query, LTG_GETRNODE(key)) < 0)
670 :
671 (ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0);
672 break;
673 case 10:
674 query = PG_GETARG_LTREE_COPY(1);
675 res = (GIST_LEAF(entry)) ?
676 inner_isparent((ltree *) query, LTG_NODE(key))
677 :
678 gist_isparent(key, (ltree *) query);
679 break;
680 case 11:
681 query = PG_GETARG_LTREE(1);
682 res = (GIST_LEAF(entry)) ?
683 inner_isparent(LTG_NODE(key), (ltree *) query)
684 :
685 gist_ischild(key, (ltree *) query);
686 break;
687 case 12:
688 case 13:
689 query = PG_GETARG_LQUERY(1);
690 if (GIST_LEAF(entry))
691 res = DatumGetBool(DirectFunctionCall2(ltq_regex,
692 PointerGetDatum(LTG_NODE(key)),
693 PointerGetDatum((lquery *) query)
694 ));
695 else
696 res = (gist_qe(key, (lquery *) query) && gist_between(key, (lquery *) query));
697 break;
698 case 14:
699 case 15:
700 query = PG_GETARG_LQUERY(1);
701 if (GIST_LEAF(entry))
702 res = DatumGetBool(DirectFunctionCall2(ltxtq_exec,
703 PointerGetDatum(LTG_NODE(key)),
704 PointerGetDatum((lquery *) query)
705 ));
706 else
707 res = gist_qtxt(key, (ltxtquery *) query);
708 break;
709 case 16:
710 case 17:
711 query = DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
712 if (GIST_LEAF(entry))
713 res = DatumGetBool(DirectFunctionCall2(lt_q_regex,
714 PointerGetDatum(LTG_NODE(key)),
715 PointerGetDatum((ArrayType *) query)
716 ));
717 else
718 res = arrq_cons(key, (ArrayType *) query);
719 break;
720 default:
721 /* internal error */
722 elog(ERROR, "unrecognized StrategyNumber: %d", strategy);
723 }
724
725 PG_FREE_IF_COPY(query, 1);
726 PG_RETURN_BOOL(res);
727 }
PostgreSQL from CVS