Branch data Line data Source code
1 : : /*
2 : : * op function for ltree
3 : : * Teodor Sigaev <teodor@stack.net>
4 : : * contrib/ltree/ltree_op.c
5 : : */
6 : : #include "postgres.h"
7 : :
8 : : #include <ctype.h>
9 : :
10 : : #include "common/hashfn.h"
11 : : #include "ltree.h"
12 : : #include "utils/builtins.h"
13 : : #include "utils/selfuncs.h"
14 : : #include "varatt.h"
15 : :
16 : 3 : PG_MODULE_MAGIC_EXT(
17 : : .name = "ltree",
18 : : .version = PG_VERSION
19 : : );
20 : :
21 : : /* compare functions */
22 : 3 : PG_FUNCTION_INFO_V1(ltree_cmp);
23 : 3 : PG_FUNCTION_INFO_V1(ltree_lt);
24 : 3 : PG_FUNCTION_INFO_V1(ltree_le);
25 : 3 : PG_FUNCTION_INFO_V1(ltree_eq);
26 : 2 : PG_FUNCTION_INFO_V1(ltree_ne);
27 : 3 : PG_FUNCTION_INFO_V1(ltree_ge);
28 : 3 : PG_FUNCTION_INFO_V1(ltree_gt);
29 : 3 : PG_FUNCTION_INFO_V1(hash_ltree);
30 : 3 : PG_FUNCTION_INFO_V1(hash_ltree_extended);
31 : 3 : PG_FUNCTION_INFO_V1(nlevel);
32 : 3 : PG_FUNCTION_INFO_V1(ltree_isparent);
33 : 3 : PG_FUNCTION_INFO_V1(ltree_risparent);
34 : 3 : PG_FUNCTION_INFO_V1(subltree);
35 : 6 : PG_FUNCTION_INFO_V1(subpath);
36 : 6 : PG_FUNCTION_INFO_V1(ltree_index);
37 : 3 : PG_FUNCTION_INFO_V1(ltree_addltree);
38 : 3 : PG_FUNCTION_INFO_V1(ltree_addtext);
39 : 2 : PG_FUNCTION_INFO_V1(ltree_textadd);
40 : 16 : PG_FUNCTION_INFO_V1(lca);
41 : 3 : PG_FUNCTION_INFO_V1(ltree2text);
42 : 3 : PG_FUNCTION_INFO_V1(text2ltree);
43 : 2 : PG_FUNCTION_INFO_V1(ltreeparentsel);
44 : :
45 : : /*
46 : : * btree-comparison function.
47 : : */
48 : : int
49 : 98173 : ltree_compare(const ltree *a, const ltree *b)
50 : : {
51 : 98173 : ltree_level *al = LTREE_FIRST(a);
52 : 98173 : ltree_level *bl = LTREE_FIRST(b);
53 : 98173 : int an = a->numlevel;
54 : 98173 : int bn = b->numlevel;
55 : :
56 [ + + + + ]: 185749 : while (an > 0 && bn > 0)
57 : : {
58 : : int res;
59 : :
60 : 176495 : res = memcmp(al->name, bl->name, Min(al->len, bl->len));
61 [ + + ]: 176495 : if (res == 0)
62 : : {
63 [ + + ]: 93933 : if (al->len != bl->len)
64 : 6357 : return (int) al->len - (int) bl->len;
65 : : }
66 : : else
67 : 82562 : return res;
68 : :
69 : 87576 : an--;
70 : 87576 : bn--;
71 : 87576 : al = LEVEL_NEXT(al);
72 : 87576 : bl = LEVEL_NEXT(bl);
73 : : }
74 : :
75 : 9254 : return a->numlevel - b->numlevel;
76 : : }
77 : :
78 : : /*
79 : : * Returns a "distance" between a and b. If a < b, the distance is negative,
80 : : * consistent with the ltree_compare() ordering.
81 : : */
82 : : float
83 : 19736 : ltree_compare_distance(const ltree *a, const ltree *b)
84 : : {
85 : 19736 : ltree_level *al = LTREE_FIRST(a);
86 : 19736 : ltree_level *bl = LTREE_FIRST(b);
87 : 19736 : int an = a->numlevel;
88 : 19736 : int bn = b->numlevel;
89 : :
90 [ + + + - ]: 20550 : while (an > 0 && bn > 0)
91 : : {
92 : : int res;
93 : :
94 : 18380 : res = memcmp(al->name, bl->name, Min(al->len, bl->len));
95 [ + + ]: 18380 : if (res == 0)
96 : : {
97 [ + + ]: 1947 : if (al->len != bl->len)
98 : 1133 : return (float) (al->len - bl->len) * 10.0 * (an + 1);
99 : : }
100 : : else
101 : : {
102 [ + + ]: 16433 : if (res < 0)
103 : 10603 : return -1.0 * 10.0 * (an + 1);
104 : : else
105 : 5830 : return 1.0 * 10.0 * (an + 1);
106 : : }
107 : :
108 : 814 : an--;
109 : 814 : bn--;
110 : 814 : al = LEVEL_NEXT(al);
111 : 814 : bl = LEVEL_NEXT(bl);
112 : : }
113 : :
114 : 2170 : return ((float) (a->numlevel - b->numlevel)) * 10.0 * (an + 1);
115 : : }
116 : :
117 : : #define RUNCMP \
118 : : ltree *a = PG_GETARG_LTREE_P(0); \
119 : : ltree *b = PG_GETARG_LTREE_P(1); \
120 : : int res = ltree_compare(a,b); \
121 : : PG_FREE_IF_COPY(a,0); \
122 : : PG_FREE_IF_COPY(b,1)
123 : :
124 : : Datum
125 : 51231 : ltree_cmp(PG_FUNCTION_ARGS)
126 : : {
127 [ + - + + ]: 51231 : RUNCMP;
128 : 51231 : PG_RETURN_INT32(res);
129 : : }
130 : :
131 : : Datum
132 : 2141 : ltree_lt(PG_FUNCTION_ARGS)
133 : : {
134 [ + + - + ]: 2141 : RUNCMP;
135 : 2141 : PG_RETURN_BOOL(res < 0);
136 : : }
137 : :
138 : : Datum
139 : 2141 : ltree_le(PG_FUNCTION_ARGS)
140 : : {
141 [ + + - + ]: 2141 : RUNCMP;
142 : 2141 : PG_RETURN_BOOL(res <= 0);
143 : : }
144 : :
145 : : Datum
146 : 2017 : ltree_eq(PG_FUNCTION_ARGS)
147 : : {
148 [ + + + + ]: 2017 : RUNCMP;
149 : 2017 : PG_RETURN_BOOL(res == 0);
150 : : }
151 : :
152 : : Datum
153 : 2118 : ltree_ge(PG_FUNCTION_ARGS)
154 : : {
155 [ + + - + ]: 2118 : RUNCMP;
156 : 2118 : PG_RETURN_BOOL(res >= 0);
157 : : }
158 : :
159 : : Datum
160 : 2118 : ltree_gt(PG_FUNCTION_ARGS)
161 : : {
162 [ + + - + ]: 2118 : RUNCMP;
163 : 2118 : PG_RETURN_BOOL(res > 0);
164 : : }
165 : :
166 : : Datum
167 : 0 : ltree_ne(PG_FUNCTION_ARGS)
168 : : {
169 [ # # # # ]: 0 : RUNCMP;
170 : 0 : PG_RETURN_BOOL(res != 0);
171 : : }
172 : :
173 : : /* Compute a hash for the ltree */
174 : : Datum
175 : 3031 : hash_ltree(PG_FUNCTION_ARGS)
176 : : {
177 : 3031 : ltree *a = PG_GETARG_LTREE_P(0);
178 : 3031 : uint32 result = 1;
179 : 3031 : int an = a->numlevel;
180 : 3031 : ltree_level *al = LTREE_FIRST(a);
181 : :
182 [ + + ]: 22872 : while (an > 0)
183 : : {
184 : 19841 : uint32 levelHash = DatumGetUInt32(hash_any((unsigned char *) al->name, al->len));
185 : :
186 : : /*
187 : : * Combine hash values of successive elements by multiplying the
188 : : * current value by 31 and adding on the new element's hash value.
189 : : *
190 : : * This method is borrowed from hash_array(), which see for further
191 : : * commentary.
192 : : */
193 : 19841 : result = (result << 5) - result + levelHash;
194 : :
195 : 19841 : an--;
196 : 19841 : al = LEVEL_NEXT(al);
197 : : }
198 : :
199 [ + + ]: 3031 : PG_FREE_IF_COPY(a, 0);
200 : 3031 : PG_RETURN_UINT32(result);
201 : : }
202 : :
203 : : /* Compute an extended hash for the ltree */
204 : : Datum
205 : 12 : hash_ltree_extended(PG_FUNCTION_ARGS)
206 : : {
207 : 12 : ltree *a = PG_GETARG_LTREE_P(0);
208 : 12 : const uint64 seed = PG_GETARG_INT64(1);
209 : 12 : uint64 result = 1;
210 : 12 : int an = a->numlevel;
211 : 12 : ltree_level *al = LTREE_FIRST(a);
212 : :
213 : : /*
214 : : * If the path has length zero, return 1 + seed to ensure that the low 32
215 : : * bits of the result match hash_ltree when the seed is 0, as required by
216 : : * the hash index support functions, but to also return a different value
217 : : * when there is a seed.
218 : : */
219 [ + + ]: 12 : if (an == 0)
220 : : {
221 [ - + ]: 2 : PG_FREE_IF_COPY(a, 0);
222 : 2 : PG_RETURN_UINT64(result + seed);
223 : : }
224 : :
225 [ + + ]: 28 : while (an > 0)
226 : : {
227 : 18 : uint64 levelHash = DatumGetUInt64(hash_any_extended((unsigned char *) al->name, al->len, seed));
228 : :
229 : 18 : result = (result << 5) - result + levelHash;
230 : :
231 : 18 : an--;
232 : 18 : al = LEVEL_NEXT(al);
233 : : }
234 : :
235 [ - + ]: 10 : PG_FREE_IF_COPY(a, 0);
236 : 10 : PG_RETURN_UINT64(result);
237 : : }
238 : :
239 : : Datum
240 : 2 : nlevel(PG_FUNCTION_ARGS)
241 : : {
242 : 2 : ltree *a = PG_GETARG_LTREE_P(0);
243 : 2 : int res = a->numlevel;
244 : :
245 [ - + ]: 2 : PG_FREE_IF_COPY(a, 0);
246 : 2 : PG_RETURN_INT32(res);
247 : : }
248 : :
249 : : bool
250 : 21188 : inner_isparent(const ltree *c, const ltree *p)
251 : : {
252 : 21188 : ltree_level *cl = LTREE_FIRST(c);
253 : 21188 : ltree_level *pl = LTREE_FIRST(p);
254 : 21188 : int pn = p->numlevel;
255 : :
256 [ + + ]: 21188 : if (pn > c->numlevel)
257 : 10166 : return false;
258 : :
259 [ + + ]: 12019 : while (pn > 0)
260 : : {
261 [ + + ]: 11883 : if (cl->len != pl->len)
262 : 7960 : return false;
263 [ + + ]: 3923 : if (memcmp(cl->name, pl->name, cl->len) != 0)
264 : 2926 : return false;
265 : :
266 : 997 : pn--;
267 : 997 : cl = LEVEL_NEXT(cl);
268 : 997 : pl = LEVEL_NEXT(pl);
269 : : }
270 : 136 : return true;
271 : : }
272 : :
273 : : Datum
274 : 11538 : ltree_isparent(PG_FUNCTION_ARGS)
275 : : {
276 : 11538 : ltree *c = PG_GETARG_LTREE_P(1);
277 : 11538 : ltree *p = PG_GETARG_LTREE_P(0);
278 : 11538 : bool res = inner_isparent(c, p);
279 : :
280 [ - + ]: 11538 : PG_FREE_IF_COPY(c, 1);
281 [ + + ]: 11538 : PG_FREE_IF_COPY(p, 0);
282 : 11538 : PG_RETURN_BOOL(res);
283 : : }
284 : :
285 : : Datum
286 : 9320 : ltree_risparent(PG_FUNCTION_ARGS)
287 : : {
288 : 9320 : ltree *c = PG_GETARG_LTREE_P(0);
289 : 9320 : ltree *p = PG_GETARG_LTREE_P(1);
290 : 9320 : bool res = inner_isparent(c, p);
291 : :
292 [ + + ]: 9320 : PG_FREE_IF_COPY(c, 0);
293 [ - + ]: 9320 : PG_FREE_IF_COPY(p, 1);
294 : 9320 : PG_RETURN_BOOL(res);
295 : : }
296 : :
297 : :
298 : : static ltree *
299 : 10 : inner_subltree(ltree *t, int32 startpos, int32 endpos)
300 : : {
301 : 10 : char *start = NULL,
302 : 10 : *end = NULL;
303 : 10 : ltree_level *ptr = LTREE_FIRST(t);
304 : : ltree *res;
305 : : int i;
306 : :
307 [ + + + - : 10 : if (startpos < 0 || endpos < 0 || startpos >= t->numlevel || startpos > endpos)
+ - - + ]
308 [ + - ]: 1 : ereport(ERROR,
309 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
310 : : errmsg("invalid positions")));
311 : :
312 [ + + ]: 9 : if (endpos > t->numlevel)
313 : 2 : endpos = t->numlevel;
314 : :
315 : 9 : start = end = (char *) ptr;
316 [ + + ]: 19 : for (i = 0; i < endpos; i++)
317 : : {
318 [ + + ]: 18 : if (i == startpos)
319 : 7 : start = (char *) ptr;
320 [ + + ]: 18 : if (i == endpos - 1)
321 : : {
322 : 8 : end = (char *) LEVEL_NEXT(ptr);
323 : 8 : break;
324 : : }
325 : 10 : ptr = LEVEL_NEXT(ptr);
326 : : }
327 : :
328 : 9 : res = (ltree *) palloc0(LTREE_HDRSIZE + (end - start));
329 : 9 : SET_VARSIZE(res, LTREE_HDRSIZE + (end - start));
330 : 9 : res->numlevel = endpos - startpos;
331 : :
332 : 9 : memcpy(LTREE_FIRST(res), start, end - start);
333 : :
334 : 9 : return res;
335 : : }
336 : :
337 : : Datum
338 : 1 : subltree(PG_FUNCTION_ARGS)
339 : : {
340 : 1 : ltree *t = PG_GETARG_LTREE_P(0);
341 : 1 : ltree *res = inner_subltree(t, PG_GETARG_INT32(1), PG_GETARG_INT32(2));
342 : :
343 [ - + ]: 1 : PG_FREE_IF_COPY(t, 0);
344 : 1 : PG_RETURN_POINTER(res);
345 : : }
346 : :
347 : : Datum
348 : 9 : subpath(PG_FUNCTION_ARGS)
349 : : {
350 : 9 : ltree *t = PG_GETARG_LTREE_P(0);
351 : 9 : int32 start = PG_GETARG_INT32(1);
352 [ + + ]: 9 : int32 len = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
353 : : int32 end;
354 : : ltree *res;
355 : :
356 [ + + ]: 9 : if (start < 0)
357 : 2 : start = t->numlevel + start;
358 : :
359 [ + + ]: 9 : if (len < 0)
360 : 2 : end = t->numlevel + len;
361 [ + + ]: 7 : else if (len == 0)
362 [ + + ]: 5 : end = (fcinfo->nargs == 3) ? start : LTREE_MAX_LEVELS;
363 : : else
364 : 2 : end = start + len;
365 : :
366 : 9 : res = inner_subltree(t, start, end);
367 : :
368 [ - + ]: 8 : PG_FREE_IF_COPY(t, 0);
369 : 8 : PG_RETURN_POINTER(res);
370 : : }
371 : :
372 : : static ltree *
373 : 6 : ltree_concat(ltree *a, ltree *b)
374 : : {
375 : : ltree *r;
376 : 6 : int numlevel = (int) a->numlevel + b->numlevel;
377 : :
378 [ + + ]: 6 : if (numlevel > LTREE_MAX_LEVELS)
379 [ + - ]: 1 : ereport(ERROR,
380 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
381 : : errmsg("number of ltree levels (%d) exceeds the maximum allowed (%d)",
382 : : numlevel, LTREE_MAX_LEVELS)));
383 : :
384 : 5 : r = (ltree *) palloc0(VARSIZE(a) + VARSIZE(b) - LTREE_HDRSIZE);
385 : 5 : SET_VARSIZE(r, VARSIZE(a) + VARSIZE(b) - LTREE_HDRSIZE);
386 : 5 : r->numlevel = (uint16) numlevel;
387 : :
388 : 5 : memcpy(LTREE_FIRST(r), LTREE_FIRST(a), VARSIZE(a) - LTREE_HDRSIZE);
389 : 5 : memcpy(((char *) LTREE_FIRST(r)) + VARSIZE(a) - LTREE_HDRSIZE,
390 : : LTREE_FIRST(b),
391 : 5 : VARSIZE(b) - LTREE_HDRSIZE);
392 : 5 : return r;
393 : : }
394 : :
395 : : Datum
396 : 5 : ltree_addltree(PG_FUNCTION_ARGS)
397 : : {
398 : 5 : ltree *a = PG_GETARG_LTREE_P(0);
399 : 5 : ltree *b = PG_GETARG_LTREE_P(1);
400 : : ltree *r;
401 : :
402 : 5 : r = ltree_concat(a, b);
403 [ - + ]: 4 : PG_FREE_IF_COPY(a, 0);
404 [ - + ]: 4 : PG_FREE_IF_COPY(b, 1);
405 : 4 : PG_RETURN_POINTER(r);
406 : : }
407 : :
408 : : Datum
409 : 1 : ltree_addtext(PG_FUNCTION_ARGS)
410 : : {
411 : 1 : ltree *a = PG_GETARG_LTREE_P(0);
412 : 1 : text *b = PG_GETARG_TEXT_PP(1);
413 : : char *s;
414 : : ltree *r,
415 : : *tmp;
416 : :
417 : 1 : s = text_to_cstring(b);
418 : :
419 : 1 : tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
420 : : PointerGetDatum(s)));
421 : :
422 : 1 : pfree(s);
423 : :
424 : 1 : r = ltree_concat(a, tmp);
425 : :
426 : 1 : pfree(tmp);
427 : :
428 [ - + ]: 1 : PG_FREE_IF_COPY(a, 0);
429 [ - + ]: 1 : PG_FREE_IF_COPY(b, 1);
430 : 1 : PG_RETURN_POINTER(r);
431 : : }
432 : :
433 : : Datum
434 : 18 : ltree_index(PG_FUNCTION_ARGS)
435 : : {
436 : 18 : ltree *a = PG_GETARG_LTREE_P(0);
437 : 18 : ltree *b = PG_GETARG_LTREE_P(1);
438 [ + + ]: 18 : int start = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
439 : : int i,
440 : : j;
441 : : ltree_level *startptr,
442 : : *aptr,
443 : : *bptr;
444 : 18 : bool found = false;
445 : :
446 [ + + ]: 18 : if (start < 0)
447 : : {
448 [ + + ]: 5 : if (-start >= a->numlevel)
449 : 1 : start = 0;
450 : : else
451 : 4 : start = (int) (a->numlevel) + start;
452 : : }
453 : :
454 [ + + + - : 18 : if (a->numlevel - start < b->numlevel || a->numlevel == 0 || b->numlevel == 0)
- + ]
455 : : {
456 [ - + ]: 1 : PG_FREE_IF_COPY(a, 0);
457 [ - + ]: 1 : PG_FREE_IF_COPY(b, 1);
458 : 1 : PG_RETURN_INT32(-1);
459 : : }
460 : :
461 : 17 : startptr = LTREE_FIRST(a);
462 [ + + ]: 109 : for (i = 0; i <= a->numlevel - b->numlevel; i++)
463 : : {
464 [ + + ]: 106 : if (i >= start)
465 : : {
466 : 58 : aptr = startptr;
467 : 58 : bptr = LTREE_FIRST(b);
468 [ + + ]: 93 : for (j = 0; j < b->numlevel; j++)
469 : : {
470 [ + - + + ]: 79 : if (!(aptr->len == bptr->len && memcmp(aptr->name, bptr->name, aptr->len) == 0))
471 : : break;
472 : 35 : aptr = LEVEL_NEXT(aptr);
473 : 35 : bptr = LEVEL_NEXT(bptr);
474 : : }
475 : :
476 [ + + ]: 58 : if (j == b->numlevel)
477 : : {
478 : 14 : found = true;
479 : 14 : break;
480 : : }
481 : : }
482 : 92 : startptr = LEVEL_NEXT(startptr);
483 : : }
484 : :
485 [ + + ]: 17 : if (!found)
486 : 3 : i = -1;
487 : :
488 [ - + ]: 17 : PG_FREE_IF_COPY(a, 0);
489 [ - + ]: 17 : PG_FREE_IF_COPY(b, 1);
490 : 17 : PG_RETURN_INT32(i);
491 : : }
492 : :
493 : : Datum
494 : 0 : ltree_textadd(PG_FUNCTION_ARGS)
495 : : {
496 : 0 : ltree *a = PG_GETARG_LTREE_P(1);
497 : 0 : text *b = PG_GETARG_TEXT_PP(0);
498 : : char *s;
499 : : ltree *r,
500 : : *tmp;
501 : :
502 : 0 : s = text_to_cstring(b);
503 : :
504 : 0 : tmp = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
505 : : PointerGetDatum(s)));
506 : :
507 : 0 : pfree(s);
508 : :
509 : 0 : r = ltree_concat(tmp, a);
510 : :
511 : 0 : pfree(tmp);
512 : :
513 [ # # ]: 0 : PG_FREE_IF_COPY(a, 1);
514 [ # # ]: 0 : PG_FREE_IF_COPY(b, 0);
515 : 0 : PG_RETURN_POINTER(r);
516 : : }
517 : :
518 : : /*
519 : : * Common code for variants of lca(), find longest common ancestor of inputs
520 : : *
521 : : * Returns NULL if there is no common ancestor, ie, the longest common
522 : : * prefix is empty.
523 : : */
524 : : ltree *
525 : 14 : lca_inner(ltree **a, int len)
526 : : {
527 : : int tmp,
528 : : num,
529 : : i,
530 : : reslen;
531 : : ltree **ptr;
532 : : ltree_level *l1,
533 : : *l2;
534 : : ltree *res;
535 : :
536 [ + + ]: 14 : if (len <= 0)
537 : 1 : return NULL; /* no inputs? */
538 [ + + ]: 13 : if ((*a)->numlevel == 0)
539 : 1 : return NULL; /* any empty input means NULL result */
540 : :
541 : : /* num is the length of the longest common ancestor so far */
542 : 12 : num = (*a)->numlevel - 1;
543 : :
544 : : /* Compare each additional input to *a */
545 : 12 : ptr = a + 1;
546 [ + + ]: 23 : while (ptr - a < len)
547 : : {
548 [ + + ]: 12 : if ((*ptr)->numlevel == 0)
549 : 1 : return NULL;
550 [ + + ]: 11 : else if ((*ptr)->numlevel == 1)
551 : 2 : num = 0;
552 : : else
553 : : {
554 : 9 : l1 = LTREE_FIRST(*a);
555 : 9 : l2 = LTREE_FIRST(*ptr);
556 : 9 : tmp = Min(num, (*ptr)->numlevel - 1);
557 : 9 : num = 0;
558 [ + + ]: 23 : for (i = 0; i < tmp; i++)
559 : : {
560 [ + + ]: 21 : if (l1->len == l2->len &&
561 [ + + ]: 18 : memcmp(l1->name, l2->name, l1->len) == 0)
562 : 14 : num = i + 1;
563 : : else
564 : : break;
565 : 14 : l1 = LEVEL_NEXT(l1);
566 : 14 : l2 = LEVEL_NEXT(l2);
567 : : }
568 : : }
569 : 11 : ptr++;
570 : : }
571 : :
572 : : /* Now compute size of result ... */
573 : 11 : reslen = LTREE_HDRSIZE;
574 : 11 : l1 = LTREE_FIRST(*a);
575 [ + + ]: 21 : for (i = 0; i < num; i++)
576 : : {
577 : 10 : reslen += MAXALIGN(l1->len + LEVEL_HDRSIZE);
578 : 10 : l1 = LEVEL_NEXT(l1);
579 : : }
580 : :
581 : : /* ... and construct it by copying from *a */
582 : 11 : res = (ltree *) palloc0(reslen);
583 : 11 : SET_VARSIZE(res, reslen);
584 : 11 : res->numlevel = num;
585 : :
586 : 11 : l1 = LTREE_FIRST(*a);
587 : 11 : l2 = LTREE_FIRST(res);
588 : :
589 [ + + ]: 21 : for (i = 0; i < num; i++)
590 : : {
591 : 10 : memcpy(l2, l1, MAXALIGN(l1->len + LEVEL_HDRSIZE));
592 : 10 : l1 = LEVEL_NEXT(l1);
593 : 10 : l2 = LEVEL_NEXT(l2);
594 : : }
595 : :
596 : 11 : return res;
597 : : }
598 : :
599 : : Datum
600 : 6 : lca(PG_FUNCTION_ARGS)
601 : : {
602 : : int i;
603 : : ltree **a,
604 : : *res;
605 : :
606 : 6 : a = palloc_array(ltree *, fcinfo->nargs);
607 [ + + ]: 21 : for (i = 0; i < fcinfo->nargs; i++)
608 : 15 : a[i] = PG_GETARG_LTREE_P(i);
609 : 6 : res = lca_inner(a, (int) fcinfo->nargs);
610 [ + + ]: 21 : for (i = 0; i < fcinfo->nargs; i++)
611 [ - + ]: 15 : PG_FREE_IF_COPY(a[i], i);
612 : 6 : pfree(a);
613 : :
614 [ + + ]: 6 : if (res)
615 : 5 : PG_RETURN_POINTER(res);
616 : : else
617 : 1 : PG_RETURN_NULL();
618 : : }
619 : :
620 : : Datum
621 : 1 : text2ltree(PG_FUNCTION_ARGS)
622 : : {
623 : 1 : text *in = PG_GETARG_TEXT_PP(0);
624 : : char *s;
625 : : ltree *out;
626 : :
627 : 1 : s = text_to_cstring(in);
628 : :
629 : 1 : out = (ltree *) DatumGetPointer(DirectFunctionCall1(ltree_in,
630 : : PointerGetDatum(s)));
631 : 1 : pfree(s);
632 [ - + ]: 1 : PG_FREE_IF_COPY(in, 0);
633 : 1 : PG_RETURN_POINTER(out);
634 : : }
635 : :
636 : :
637 : : Datum
638 : 1 : ltree2text(PG_FUNCTION_ARGS)
639 : : {
640 : 1 : ltree *in = PG_GETARG_LTREE_P(0);
641 : : char *ptr;
642 : : int i;
643 : : ltree_level *curlevel;
644 : : text *out;
645 : :
646 : 1 : out = (text *) palloc(VARSIZE(in) + VARHDRSZ);
647 : 1 : ptr = VARDATA(out);
648 : 1 : curlevel = LTREE_FIRST(in);
649 [ + + ]: 6 : for (i = 0; i < in->numlevel; i++)
650 : : {
651 [ + + ]: 5 : if (i != 0)
652 : : {
653 : 4 : *ptr = '.';
654 : 4 : ptr++;
655 : : }
656 : 5 : memcpy(ptr, curlevel->name, curlevel->len);
657 : 5 : ptr += curlevel->len;
658 : 5 : curlevel = LEVEL_NEXT(curlevel);
659 : : }
660 : :
661 : 1 : SET_VARSIZE(out, ptr - ((char *) out));
662 [ - + ]: 1 : PG_FREE_IF_COPY(in, 0);
663 : :
664 : 1 : PG_RETURN_POINTER(out);
665 : : }
666 : :
667 : :
668 : : /*
669 : : * ltreeparentsel - Selectivity of parent relationship for ltree data types.
670 : : *
671 : : * This function is not used anymore, if the ltree extension has been
672 : : * updated to 1.2 or later.
673 : : */
674 : : Datum
675 : 0 : ltreeparentsel(PG_FUNCTION_ARGS)
676 : : {
677 : 0 : PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
678 : 0 : Oid operator = PG_GETARG_OID(1);
679 : 0 : List *args = (List *) PG_GETARG_POINTER(2);
680 : 0 : int varRelid = PG_GETARG_INT32(3);
681 : : double selec;
682 : :
683 : : /* Use generic restriction selectivity logic, with default 0.001. */
684 : 0 : selec = generic_restriction_selectivity(root, operator, InvalidOid,
685 : : args, varRelid,
686 : : 0.001);
687 : :
688 : 0 : PG_RETURN_FLOAT8((float8) selec);
689 : : }
|
