Branch data Line data Source code
1 : : /*
2 : : * contrib/hstore/hstore_op.c
3 : : */
4 : : #include "postgres.h"
5 : :
6 : : #include "access/htup_details.h"
7 : : #include "catalog/pg_type.h"
8 : : #include "common/hashfn.h"
9 : : #include "funcapi.h"
10 : : #include "hstore.h"
11 : : #include "utils/builtins.h"
12 : : #include "utils/memutils.h"
13 : :
14 : : /* old names for C functions */
15 : 0 : HSTORE_POLLUTE(hstore_fetchval, fetchval);
16 : 0 : HSTORE_POLLUTE(hstore_exists, exists);
17 : 0 : HSTORE_POLLUTE(hstore_defined, defined);
18 : 0 : HSTORE_POLLUTE(hstore_delete, delete);
19 : 0 : HSTORE_POLLUTE(hstore_concat, hs_concat);
20 : 0 : HSTORE_POLLUTE(hstore_contains, hs_contains);
21 : 0 : HSTORE_POLLUTE(hstore_contained, hs_contained);
22 : 0 : HSTORE_POLLUTE(hstore_akeys, akeys);
23 : 0 : HSTORE_POLLUTE(hstore_avals, avals);
24 : 0 : HSTORE_POLLUTE(hstore_skeys, skeys);
25 : 0 : HSTORE_POLLUTE(hstore_svals, svals);
26 : 0 : HSTORE_POLLUTE(hstore_each, each);
27 : :
28 : :
29 : : /*
30 : : * We're often finding a sequence of keys in ascending order. The
31 : : * "lowbound" parameter is used to cache lower bounds of searches
32 : : * between calls, based on this assumption. Pass NULL for it for
33 : : * one-off or unordered searches.
34 : : */
35 : : int
36 : 9456 : hstoreFindKey(HStore *hs, int *lowbound, char *key, int keylen)
37 : : {
38 : 9456 : HEntry *entries = ARRPTR(hs);
39 [ + + ]: 9456 : int stopLow = lowbound ? *lowbound : 0;
40 : 9456 : int stopHigh = HS_COUNT(hs);
41 : : int stopMiddle;
42 : 9456 : char *base = STRPTR(hs);
43 : :
44 [ + + ]: 24849 : while (stopLow < stopHigh)
45 : : {
46 : : int difference;
47 : :
48 : 18556 : stopMiddle = stopLow + (stopHigh - stopLow) / 2;
49 : :
50 [ + + + + ]: 18556 : if (HSTORE_KEYLEN(entries, stopMiddle) == keylen)
51 [ + + ]: 7413 : difference = memcmp(HSTORE_KEY(entries, base, stopMiddle), key, keylen);
52 : : else
53 [ + + + + ]: 11143 : difference = (HSTORE_KEYLEN(entries, stopMiddle) > keylen) ? 1 : -1;
54 : :
55 [ + + ]: 18556 : if (difference == 0)
56 : : {
57 [ + + ]: 3163 : if (lowbound)
58 : 2519 : *lowbound = stopMiddle + 1;
59 : 3163 : return stopMiddle;
60 : : }
61 [ + + ]: 15393 : else if (difference < 0)
62 : 8228 : stopLow = stopMiddle + 1;
63 : : else
64 : 7165 : stopHigh = stopMiddle;
65 : : }
66 : :
67 [ + + ]: 6293 : if (lowbound)
68 : 5329 : *lowbound = stopLow;
69 : 6293 : return -1;
70 : : }
71 : :
72 : : Pairs *
73 : 2842 : hstoreArrayToPairs(ArrayType *a, int *npairs)
74 : : {
75 : : Datum *key_datums;
76 : : bool *key_nulls;
77 : : int key_count;
78 : : Pairs *key_pairs;
79 : : int bufsiz;
80 : : int i,
81 : : j;
82 : :
83 : 2842 : deconstruct_array_builtin(a, TEXTOID, &key_datums, &key_nulls, &key_count);
84 : :
85 [ + + ]: 2842 : if (key_count == 0)
86 : : {
87 : 5 : *npairs = 0;
88 : 5 : return NULL;
89 : : }
90 : :
91 : : /*
92 : : * A text array uses at least eight bytes per element, so any overflow in
93 : : * "key_count * sizeof(Pairs)" is small enough for palloc() to catch.
94 : : * However, credible improvements to the array format could invalidate
95 : : * that assumption. Therefore, use an explicit check rather than relying
96 : : * on palloc() to complain.
97 : : */
98 [ - + ]: 2837 : if (key_count > MaxAllocSize / sizeof(Pairs))
99 [ # # ]: 0 : ereport(ERROR,
100 : : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
101 : : errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
102 : : key_count, (int) (MaxAllocSize / sizeof(Pairs)))));
103 : :
104 : 2837 : key_pairs = palloc(sizeof(Pairs) * key_count);
105 : :
106 [ + + ]: 8516 : for (i = 0, j = 0; i < key_count; i++)
107 : : {
108 [ + - ]: 5679 : if (!key_nulls[i])
109 : : {
110 : 5679 : key_pairs[j].key = VARDATA(DatumGetPointer(key_datums[i]));
111 : 5679 : key_pairs[j].keylen = VARSIZE(DatumGetPointer(key_datums[i])) - VARHDRSZ;
112 : 5679 : key_pairs[j].val = NULL;
113 : 5679 : key_pairs[j].vallen = 0;
114 : 5679 : key_pairs[j].needfree = 0;
115 : 5679 : key_pairs[j].isnull = 1;
116 : 5679 : j++;
117 : : }
118 : : }
119 : :
120 : 2837 : *npairs = hstoreUniquePairs(key_pairs, j, &bufsiz);
121 : :
122 : 2837 : return key_pairs;
123 : : }
124 : :
125 : :
126 : 8 : PG_FUNCTION_INFO_V1(hstore_fetchval);
127 : : Datum
128 : 6 : hstore_fetchval(PG_FUNCTION_ARGS)
129 : : {
130 : 6 : HStore *hs = PG_GETARG_HSTORE_P(0);
131 : 6 : text *key = PG_GETARG_TEXT_PP(1);
132 : 6 : HEntry *entries = ARRPTR(hs);
133 : : text *out;
134 : 6 : int idx = hstoreFindKey(hs, NULL,
135 : 6 : VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
136 : :
137 [ + + + + ]: 6 : if (idx < 0 || HSTORE_VALISNULL(entries, idx))
138 : 2 : PG_RETURN_NULL();
139 : :
140 [ + - ]: 4 : out = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), idx),
141 [ - + ]: 4 : HSTORE_VALLEN(entries, idx));
142 : :
143 : 4 : PG_RETURN_TEXT_P(out);
144 : : }
145 : :
146 : :
147 : 16 : PG_FUNCTION_INFO_V1(hstore_exists);
148 : : Datum
149 : 1440 : hstore_exists(PG_FUNCTION_ARGS)
150 : : {
151 : 1440 : HStore *hs = PG_GETARG_HSTORE_P(0);
152 : 1440 : text *key = PG_GETARG_TEXT_PP(1);
153 : 1440 : int idx = hstoreFindKey(hs, NULL,
154 : 1440 : VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
155 : :
156 : 1440 : PG_RETURN_BOOL(idx >= 0);
157 : : }
158 : :
159 : :
160 : 8 : PG_FUNCTION_INFO_V1(hstore_exists_any);
161 : : Datum
162 : 1727 : hstore_exists_any(PG_FUNCTION_ARGS)
163 : : {
164 : 1727 : HStore *hs = PG_GETARG_HSTORE_P(0);
165 : 1727 : ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
166 : : int nkeys;
167 : 1727 : Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);
168 : : int i;
169 : 1727 : int lowbound = 0;
170 : 1727 : bool res = false;
171 : :
172 : : /*
173 : : * we exploit the fact that the pairs list is already sorted into strictly
174 : : * increasing order to narrow the hstoreFindKey search; each search can
175 : : * start one entry past the previous "found" entry, or at the lower bound
176 : : * of the last search.
177 : : */
178 [ + + ]: 3580 : for (i = 0; i < nkeys; i++)
179 : : {
180 : 2867 : int idx = hstoreFindKey(hs, &lowbound,
181 : 2867 : key_pairs[i].key, key_pairs[i].keylen);
182 : :
183 [ + + ]: 2867 : if (idx >= 0)
184 : : {
185 : 1014 : res = true;
186 : 1014 : break;
187 : : }
188 : : }
189 : :
190 : 1727 : PG_RETURN_BOOL(res);
191 : : }
192 : :
193 : :
194 : 8 : PG_FUNCTION_INFO_V1(hstore_exists_all);
195 : : Datum
196 : 1097 : hstore_exists_all(PG_FUNCTION_ARGS)
197 : : {
198 : 1097 : HStore *hs = PG_GETARG_HSTORE_P(0);
199 : 1097 : ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
200 : : int nkeys;
201 : 1097 : Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);
202 : : int i;
203 : 1097 : int lowbound = 0;
204 : 1097 : bool res = true;
205 : :
206 : : /*
207 : : * we exploit the fact that the pairs list is already sorted into strictly
208 : : * increasing order to narrow the hstoreFindKey search; each search can
209 : : * start one entry past the previous "found" entry, or at the lower bound
210 : : * of the last search.
211 : : */
212 [ + + ]: 1507 : for (i = 0; i < nkeys; i++)
213 : : {
214 : 1378 : int idx = hstoreFindKey(hs, &lowbound,
215 : 1378 : key_pairs[i].key, key_pairs[i].keylen);
216 : :
217 [ + + ]: 1378 : if (idx < 0)
218 : : {
219 : 968 : res = false;
220 : 968 : break;
221 : : }
222 : : }
223 : :
224 : 1097 : PG_RETURN_BOOL(res);
225 : : }
226 : :
227 : :
228 : 15 : PG_FUNCTION_INFO_V1(hstore_defined);
229 : : Datum
230 : 4 : hstore_defined(PG_FUNCTION_ARGS)
231 : : {
232 : 4 : HStore *hs = PG_GETARG_HSTORE_P(0);
233 : 4 : text *key = PG_GETARG_TEXT_PP(1);
234 : 4 : HEntry *entries = ARRPTR(hs);
235 : 4 : int idx = hstoreFindKey(hs, NULL,
236 : 4 : VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
237 [ + + + + ]: 4 : bool res = (idx >= 0 && !HSTORE_VALISNULL(entries, idx));
238 : :
239 : 4 : PG_RETURN_BOOL(res);
240 : : }
241 : :
242 : :
243 : 8 : PG_FUNCTION_INFO_V1(hstore_delete);
244 : : Datum
245 : 11 : hstore_delete(PG_FUNCTION_ARGS)
246 : : {
247 : 11 : HStore *hs = PG_GETARG_HSTORE_P(0);
248 : 11 : text *key = PG_GETARG_TEXT_PP(1);
249 : 11 : char *keyptr = VARDATA_ANY(key);
250 : 11 : int keylen = VARSIZE_ANY_EXHDR(key);
251 : 11 : HStore *out = palloc(VARSIZE(hs));
252 : : char *bufs,
253 : : *bufd,
254 : : *ptrd;
255 : : HEntry *es,
256 : : *ed;
257 : : int i;
258 : 11 : int count = HS_COUNT(hs);
259 : 11 : int outcount = 0;
260 : :
261 : 11 : SET_VARSIZE(out, VARSIZE(hs));
262 : 11 : HS_SETCOUNT(out, count); /* temporary! */
263 : :
264 : 11 : bufs = STRPTR(hs);
265 : 11 : es = ARRPTR(hs);
266 : 11 : bufd = ptrd = STRPTR(out);
267 : 11 : ed = ARRPTR(out);
268 : :
269 [ + + ]: 44 : for (i = 0; i < count; ++i)
270 : : {
271 [ + + ]: 33 : int len = HSTORE_KEYLEN(es, i);
272 [ + + ]: 33 : char *ptrs = HSTORE_KEY(es, bufs, i);
273 : :
274 [ + - + + ]: 33 : if (!(len == keylen && memcmp(ptrs, keyptr, keylen) == 0))
275 : : {
276 [ - + ]: 24 : int vallen = HSTORE_VALLEN(es, i);
277 : :
278 : 24 : HS_COPYITEM(ed, bufd, ptrd, ptrs, len, vallen,
279 : : HSTORE_VALISNULL(es, i));
280 : 24 : ++outcount;
281 : : }
282 : : }
283 : :
284 [ + - + + ]: 11 : HS_FINALIZE(out, outcount, bufd, ptrd);
285 : :
286 : 11 : PG_RETURN_POINTER(out);
287 : : }
288 : :
289 : :
290 : 8 : PG_FUNCTION_INFO_V1(hstore_delete_array);
291 : : Datum
292 : 12 : hstore_delete_array(PG_FUNCTION_ARGS)
293 : : {
294 : 12 : HStore *hs = PG_GETARG_HSTORE_P(0);
295 : 12 : HStore *out = palloc(VARSIZE(hs));
296 : 12 : int hs_count = HS_COUNT(hs);
297 : : char *ps,
298 : : *bufd,
299 : : *pd;
300 : : HEntry *es,
301 : : *ed;
302 : : int i,
303 : : j;
304 : 12 : int outcount = 0;
305 : 12 : ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);
306 : : int nkeys;
307 : 12 : Pairs *key_pairs = hstoreArrayToPairs(key_array, &nkeys);
308 : :
309 : 12 : SET_VARSIZE(out, VARSIZE(hs));
310 : 12 : HS_SETCOUNT(out, hs_count); /* temporary! */
311 : :
312 : 12 : ps = STRPTR(hs);
313 : 12 : es = ARRPTR(hs);
314 : 12 : bufd = pd = STRPTR(out);
315 : 12 : ed = ARRPTR(out);
316 : :
317 [ + + ]: 12 : if (nkeys == 0)
318 : : {
319 : : /* return a copy of the input, unchanged */
320 : 3 : memcpy(out, hs, VARSIZE(hs));
321 [ + - ]: 3 : HS_FIXSIZE(out, hs_count);
322 : 3 : HS_SETCOUNT(out, hs_count);
323 : 3 : PG_RETURN_POINTER(out);
324 : : }
325 : :
326 : : /*
327 : : * this is in effect a merge between hs and key_pairs, both of which are
328 : : * already sorted by (keylen,key); we take keys from hs only
329 : : */
330 : :
331 [ + + ]: 36 : for (i = j = 0; i < hs_count;)
332 : : {
333 : : int difference;
334 : :
335 [ - + ]: 27 : if (j >= nkeys)
336 : 0 : difference = -1;
337 : : else
338 : : {
339 [ + + ]: 27 : int skeylen = HSTORE_KEYLEN(es, i);
340 : :
341 [ + - ]: 27 : if (skeylen == key_pairs[j].keylen)
342 : 27 : difference = memcmp(HSTORE_KEY(es, ps, i),
343 : 27 : key_pairs[j].key,
344 [ + + ]: 27 : key_pairs[j].keylen);
345 : : else
346 [ # # ]: 0 : difference = (skeylen > key_pairs[j].keylen) ? 1 : -1;
347 : : }
348 : :
349 [ - + ]: 27 : if (difference > 0)
350 : 0 : ++j;
351 [ + + ]: 27 : else if (difference == 0)
352 : 14 : ++i, ++j;
353 : : else
354 : : {
355 [ + + - + : 13 : HS_COPYITEM(ed, bufd, pd,
+ + + + -
+ - + ]
356 : : HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
357 : : HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));
358 : 13 : ++outcount;
359 : 13 : ++i;
360 : : }
361 : : }
362 : :
363 [ + + + + ]: 9 : HS_FINALIZE(out, outcount, bufd, pd);
364 : :
365 : 9 : PG_RETURN_POINTER(out);
366 : : }
367 : :
368 : :
369 : 8 : PG_FUNCTION_INFO_V1(hstore_delete_hstore);
370 : : Datum
371 : 12 : hstore_delete_hstore(PG_FUNCTION_ARGS)
372 : : {
373 : 12 : HStore *hs = PG_GETARG_HSTORE_P(0);
374 : 12 : HStore *hs2 = PG_GETARG_HSTORE_P(1);
375 : 12 : HStore *out = palloc(VARSIZE(hs));
376 : 12 : int hs_count = HS_COUNT(hs);
377 : 12 : int hs2_count = HS_COUNT(hs2);
378 : : char *ps,
379 : : *ps2,
380 : : *bufd,
381 : : *pd;
382 : : HEntry *es,
383 : : *es2,
384 : : *ed;
385 : : int i,
386 : : j;
387 : 12 : int outcount = 0;
388 : :
389 : 12 : SET_VARSIZE(out, VARSIZE(hs));
390 : 12 : HS_SETCOUNT(out, hs_count); /* temporary! */
391 : :
392 : 12 : ps = STRPTR(hs);
393 : 12 : es = ARRPTR(hs);
394 : 12 : ps2 = STRPTR(hs2);
395 : 12 : es2 = ARRPTR(hs2);
396 : 12 : bufd = pd = STRPTR(out);
397 : 12 : ed = ARRPTR(out);
398 : :
399 [ + + ]: 12 : if (hs2_count == 0)
400 : : {
401 : : /* return a copy of the input, unchanged */
402 : 3 : memcpy(out, hs, VARSIZE(hs));
403 [ + - ]: 3 : HS_FIXSIZE(out, hs_count);
404 : 3 : HS_SETCOUNT(out, hs_count);
405 : 3 : PG_RETURN_POINTER(out);
406 : : }
407 : :
408 : : /*
409 : : * this is in effect a merge between hs and hs2, both of which are already
410 : : * sorted by (keylen,key); we take keys from hs only; for equal keys, we
411 : : * take the value from hs unless the values are equal
412 : : */
413 : :
414 [ + + ]: 36 : for (i = j = 0; i < hs_count;)
415 : : {
416 : : int difference;
417 : :
418 [ + + ]: 27 : if (j >= hs2_count)
419 : 5 : difference = -1;
420 : : else
421 : : {
422 [ + + ]: 22 : int skeylen = HSTORE_KEYLEN(es, i);
423 [ + + ]: 22 : int s2keylen = HSTORE_KEYLEN(es2, j);
424 : :
425 [ + + ]: 22 : if (skeylen == s2keylen)
426 : 20 : difference = memcmp(HSTORE_KEY(es, ps, i),
427 [ + + + + ]: 20 : HSTORE_KEY(es2, ps2, j),
428 : : skeylen);
429 : : else
430 [ - + ]: 2 : difference = (skeylen > s2keylen) ? 1 : -1;
431 : : }
432 : :
433 [ - + ]: 27 : if (difference > 0)
434 : 0 : ++j;
435 [ + + ]: 27 : else if (difference == 0)
436 : : {
437 [ - + ]: 17 : int svallen = HSTORE_VALLEN(es, i);
438 : 17 : int snullval = HSTORE_VALISNULL(es, i);
439 : :
440 [ + + + - ]: 17 : if (snullval != HSTORE_VALISNULL(es2, j) ||
441 [ - + + - ]: 15 : (!snullval && (svallen != HSTORE_VALLEN(es2, j) ||
442 [ + + ]: 15 : memcmp(HSTORE_VAL(es, ps, i),
443 [ + - + - ]: 15 : HSTORE_VAL(es2, ps2, j),
444 : : svallen) != 0)))
445 : : {
446 [ - + + - : 4 : HS_COPYITEM(ed, bufd, pd,
- + - + ]
447 : : HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
448 : : svallen, snullval);
449 : 4 : ++outcount;
450 : : }
451 : 17 : ++i, ++j;
452 : : }
453 : : else
454 : : {
455 [ + + - + : 10 : HS_COPYITEM(ed, bufd, pd,
+ + + + -
+ - + ]
456 : : HSTORE_KEY(es, ps, i), HSTORE_KEYLEN(es, i),
457 : : HSTORE_VALLEN(es, i), HSTORE_VALISNULL(es, i));
458 : 10 : ++outcount;
459 : 10 : ++i;
460 : : }
461 : : }
462 : :
463 [ + + + - ]: 9 : HS_FINALIZE(out, outcount, bufd, pd);
464 : :
465 : 9 : PG_RETURN_POINTER(out);
466 : : }
467 : :
468 : :
469 : 8 : PG_FUNCTION_INFO_V1(hstore_concat);
470 : : Datum
471 : 30 : hstore_concat(PG_FUNCTION_ARGS)
472 : : {
473 : 30 : HStore *s1 = PG_GETARG_HSTORE_P(0);
474 : 30 : HStore *s2 = PG_GETARG_HSTORE_P(1);
475 : 30 : HStore *out = palloc(VARSIZE(s1) + VARSIZE(s2));
476 : : char *ps1,
477 : : *ps2,
478 : : *bufd,
479 : : *pd;
480 : : HEntry *es1,
481 : : *es2,
482 : : *ed;
483 : : int s1idx;
484 : : int s2idx;
485 : 30 : int s1count = HS_COUNT(s1);
486 : 30 : int s2count = HS_COUNT(s2);
487 : 30 : int outcount = 0;
488 : :
489 : 30 : SET_VARSIZE(out, VARSIZE(s1) + VARSIZE(s2) - HSHRDSIZE);
490 : 30 : HS_SETCOUNT(out, s1count + s2count);
491 : :
492 [ + + ]: 30 : if (s1count == 0)
493 : : {
494 : : /* return a copy of the input, unchanged */
495 : 4 : memcpy(out, s2, VARSIZE(s2));
496 [ + + ]: 4 : HS_FIXSIZE(out, s2count);
497 : 4 : HS_SETCOUNT(out, s2count);
498 : 4 : PG_RETURN_POINTER(out);
499 : : }
500 : :
501 [ + + ]: 26 : if (s2count == 0)
502 : : {
503 : : /* return a copy of the input, unchanged */
504 : 2 : memcpy(out, s1, VARSIZE(s1));
505 [ + - ]: 2 : HS_FIXSIZE(out, s1count);
506 : 2 : HS_SETCOUNT(out, s1count);
507 : 2 : PG_RETURN_POINTER(out);
508 : : }
509 : :
510 : 24 : ps1 = STRPTR(s1);
511 : 24 : ps2 = STRPTR(s2);
512 : 24 : bufd = pd = STRPTR(out);
513 : 24 : es1 = ARRPTR(s1);
514 : 24 : es2 = ARRPTR(s2);
515 : 24 : ed = ARRPTR(out);
516 : :
517 : : /*
518 : : * this is in effect a merge between s1 and s2, both of which are already
519 : : * sorted by (keylen,key); we take s2 for equal keys
520 : : */
521 : :
522 [ + + + + ]: 90 : for (s1idx = s2idx = 0; s1idx < s1count || s2idx < s2count; ++outcount)
523 : : {
524 : : int difference;
525 : :
526 [ + + ]: 66 : if (s1idx >= s1count)
527 : 13 : difference = 1;
528 [ + + ]: 53 : else if (s2idx >= s2count)
529 : 7 : difference = -1;
530 : : else
531 : : {
532 [ + + ]: 46 : int s1keylen = HSTORE_KEYLEN(es1, s1idx);
533 [ + + ]: 46 : int s2keylen = HSTORE_KEYLEN(es2, s2idx);
534 : :
535 [ + + ]: 46 : if (s1keylen == s2keylen)
536 : 41 : difference = memcmp(HSTORE_KEY(es1, ps1, s1idx),
537 [ + + + + ]: 41 : HSTORE_KEY(es2, ps2, s2idx),
538 : : s1keylen);
539 : : else
540 [ + + ]: 5 : difference = (s1keylen > s2keylen) ? 1 : -1;
541 : : }
542 : :
543 [ + + ]: 66 : if (difference >= 0)
544 : : {
545 [ + + - + : 38 : HS_COPYITEM(ed, bufd, pd,
+ + + + -
+ - + ]
546 : : HSTORE_KEY(es2, ps2, s2idx), HSTORE_KEYLEN(es2, s2idx),
547 : : HSTORE_VALLEN(es2, s2idx), HSTORE_VALISNULL(es2, s2idx));
548 : 38 : ++s2idx;
549 [ + + ]: 38 : if (difference == 0)
550 : 19 : ++s1idx;
551 : : }
552 : : else
553 : : {
554 [ + + - + : 28 : HS_COPYITEM(ed, bufd, pd,
+ + + + -
+ - + ]
555 : : HSTORE_KEY(es1, ps1, s1idx), HSTORE_KEYLEN(es1, s1idx),
556 : : HSTORE_VALLEN(es1, s1idx), HSTORE_VALISNULL(es1, s1idx));
557 : 28 : ++s1idx;
558 : : }
559 : : }
560 : :
561 [ + - + + ]: 24 : HS_FINALIZE(out, outcount, bufd, pd);
562 : :
563 : 24 : PG_RETURN_POINTER(out);
564 : : }
565 : :
566 : :
567 : 8 : PG_FUNCTION_INFO_V1(hstore_slice_to_array);
568 : : Datum
569 : 4 : hstore_slice_to_array(PG_FUNCTION_ARGS)
570 : : {
571 : 4 : HStore *hs = PG_GETARG_HSTORE_P(0);
572 : 4 : HEntry *entries = ARRPTR(hs);
573 : 4 : char *ptr = STRPTR(hs);
574 : 4 : ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);
575 : : ArrayType *aout;
576 : : Datum *key_datums;
577 : : bool *key_nulls;
578 : : Datum *out_datums;
579 : : bool *out_nulls;
580 : : int key_count;
581 : : int i;
582 : :
583 : 4 : deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
584 : :
585 [ - + ]: 4 : if (key_count == 0)
586 : : {
587 : 0 : aout = construct_empty_array(TEXTOID);
588 : 0 : PG_RETURN_POINTER(aout);
589 : : }
590 : :
591 : 4 : out_datums = palloc(sizeof(Datum) * key_count);
592 : 4 : out_nulls = palloc(sizeof(bool) * key_count);
593 : :
594 [ + + ]: 15 : for (i = 0; i < key_count; ++i)
595 : : {
596 : 11 : text *key = (text *) DatumGetPointer(key_datums[i]);
597 : : int idx;
598 : :
599 [ + + ]: 11 : if (key_nulls[i])
600 : 1 : idx = -1;
601 : : else
602 : 10 : idx = hstoreFindKey(hs, NULL, VARDATA(key), VARSIZE(key) - VARHDRSZ);
603 : :
604 [ + + + + ]: 11 : if (idx < 0 || HSTORE_VALISNULL(entries, idx))
605 : : {
606 : 2 : out_nulls[i] = true;
607 : 2 : out_datums[i] = (Datum) 0;
608 : : }
609 : : else
610 : : {
611 : 9 : out_datums[i] =
612 [ - + + - ]: 9 : PointerGetDatum(cstring_to_text_with_len(HSTORE_VAL(entries, ptr, idx),
613 : : HSTORE_VALLEN(entries, idx)));
614 : 9 : out_nulls[i] = false;
615 : : }
616 : : }
617 : :
618 : 4 : aout = construct_md_array(out_datums, out_nulls,
619 : : ARR_NDIM(key_array),
620 : : ARR_DIMS(key_array),
621 : 4 : ARR_LBOUND(key_array),
622 : : TEXTOID, -1, false, TYPALIGN_INT);
623 : :
624 : 4 : PG_RETURN_POINTER(aout);
625 : : }
626 : :
627 : :
628 : 8 : PG_FUNCTION_INFO_V1(hstore_slice_to_hstore);
629 : : Datum
630 : 6 : hstore_slice_to_hstore(PG_FUNCTION_ARGS)
631 : : {
632 : 6 : HStore *hs = PG_GETARG_HSTORE_P(0);
633 : 6 : HEntry *entries = ARRPTR(hs);
634 : 6 : char *ptr = STRPTR(hs);
635 : 6 : ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);
636 : : HStore *out;
637 : : int nkeys;
638 : 6 : Pairs *key_pairs = hstoreArrayToPairs(key_array, &nkeys);
639 : : Pairs *out_pairs;
640 : : int bufsiz;
641 : 6 : int lastidx = 0;
642 : : int i;
643 : 6 : int out_count = 0;
644 : :
645 [ - + ]: 6 : if (nkeys == 0)
646 : : {
647 : 0 : out = hstorePairs(NULL, 0, 0);
648 : 0 : PG_RETURN_POINTER(out);
649 : : }
650 : :
651 : : /* hstoreArrayToPairs() checked overflow */
652 : 6 : out_pairs = palloc(sizeof(Pairs) * nkeys);
653 : 6 : bufsiz = 0;
654 : :
655 : : /*
656 : : * we exploit the fact that the pairs list is already sorted into strictly
657 : : * increasing order to narrow the hstoreFindKey search; each search can
658 : : * start one entry past the previous "found" entry, or at the lower bound
659 : : * of the last search.
660 : : */
661 : :
662 [ + + ]: 21 : for (i = 0; i < nkeys; ++i)
663 : : {
664 : 15 : int idx = hstoreFindKey(hs, &lastidx,
665 : 15 : key_pairs[i].key, key_pairs[i].keylen);
666 : :
667 [ + + ]: 15 : if (idx >= 0)
668 : : {
669 : 12 : out_pairs[out_count].key = key_pairs[i].key;
670 : 12 : bufsiz += (out_pairs[out_count].keylen = key_pairs[i].keylen);
671 [ + - ]: 12 : out_pairs[out_count].val = HSTORE_VAL(entries, ptr, idx);
672 [ - + ]: 12 : bufsiz += (out_pairs[out_count].vallen = HSTORE_VALLEN(entries, idx));
673 : 12 : out_pairs[out_count].isnull = HSTORE_VALISNULL(entries, idx);
674 : 12 : out_pairs[out_count].needfree = false;
675 : 12 : ++out_count;
676 : : }
677 : : }
678 : :
679 : : /*
680 : : * we don't use hstoreUniquePairs here because we know that the pairs list
681 : : * is already sorted and uniq'ed.
682 : : */
683 : :
684 : 6 : out = hstorePairs(out_pairs, out_count, bufsiz);
685 : :
686 : 6 : PG_RETURN_POINTER(out);
687 : : }
688 : :
689 : :
690 : 8 : PG_FUNCTION_INFO_V1(hstore_akeys);
691 : : Datum
692 : 3 : hstore_akeys(PG_FUNCTION_ARGS)
693 : : {
694 : 3 : HStore *hs = PG_GETARG_HSTORE_P(0);
695 : : Datum *d;
696 : : ArrayType *a;
697 : 3 : HEntry *entries = ARRPTR(hs);
698 : 3 : char *base = STRPTR(hs);
699 : 3 : int count = HS_COUNT(hs);
700 : : int i;
701 : :
702 [ + + ]: 3 : if (count == 0)
703 : : {
704 : 1 : a = construct_empty_array(TEXTOID);
705 : 1 : PG_RETURN_POINTER(a);
706 : : }
707 : :
708 : 2 : d = (Datum *) palloc(sizeof(Datum) * count);
709 : :
710 [ + + ]: 7 : for (i = 0; i < count; ++i)
711 : : {
712 [ + + ]: 5 : text *t = cstring_to_text_with_len(HSTORE_KEY(entries, base, i),
713 [ + + ]: 5 : HSTORE_KEYLEN(entries, i));
714 : :
715 : 5 : d[i] = PointerGetDatum(t);
716 : : }
717 : :
718 : 2 : a = construct_array_builtin(d, count, TEXTOID);
719 : :
720 : 2 : PG_RETURN_POINTER(a);
721 : : }
722 : :
723 : :
724 : 8 : PG_FUNCTION_INFO_V1(hstore_avals);
725 : : Datum
726 : 4 : hstore_avals(PG_FUNCTION_ARGS)
727 : : {
728 : 4 : HStore *hs = PG_GETARG_HSTORE_P(0);
729 : : Datum *d;
730 : : bool *nulls;
731 : : ArrayType *a;
732 : 4 : HEntry *entries = ARRPTR(hs);
733 : 4 : char *base = STRPTR(hs);
734 : 4 : int count = HS_COUNT(hs);
735 : 4 : int lb = 1;
736 : : int i;
737 : :
738 [ + + ]: 4 : if (count == 0)
739 : : {
740 : 1 : a = construct_empty_array(TEXTOID);
741 : 1 : PG_RETURN_POINTER(a);
742 : : }
743 : :
744 : 3 : d = (Datum *) palloc(sizeof(Datum) * count);
745 : 3 : nulls = (bool *) palloc(sizeof(bool) * count);
746 : :
747 [ + + ]: 12 : for (i = 0; i < count; ++i)
748 : : {
749 [ + + ]: 9 : if (HSTORE_VALISNULL(entries, i))
750 : : {
751 : 1 : d[i] = (Datum) 0;
752 : 1 : nulls[i] = true;
753 : : }
754 : : else
755 : : {
756 [ + - ]: 8 : text *item = cstring_to_text_with_len(HSTORE_VAL(entries, base, i),
757 [ - + ]: 8 : HSTORE_VALLEN(entries, i));
758 : :
759 : 8 : d[i] = PointerGetDatum(item);
760 : 8 : nulls[i] = false;
761 : : }
762 : : }
763 : :
764 : 3 : a = construct_md_array(d, nulls, 1, &count, &lb,
765 : : TEXTOID, -1, false, TYPALIGN_INT);
766 : :
767 : 3 : PG_RETURN_POINTER(a);
768 : : }
769 : :
770 : :
771 : : static ArrayType *
772 : 4 : hstore_to_array_internal(HStore *hs, int ndims)
773 : : {
774 : 4 : HEntry *entries = ARRPTR(hs);
775 : 4 : char *base = STRPTR(hs);
776 : 4 : int count = HS_COUNT(hs);
777 : 4 : int out_size[2] = {0, 2};
778 : 4 : int lb[2] = {1, 1};
779 : : Datum *out_datums;
780 : : bool *out_nulls;
781 : : int i;
782 : :
783 : : Assert(ndims < 3);
784 : :
785 [ + - - + ]: 4 : if (count == 0 || ndims == 0)
786 : 0 : return construct_empty_array(TEXTOID);
787 : :
788 : 4 : out_size[0] = count * 2 / ndims;
789 : 4 : out_datums = palloc(sizeof(Datum) * count * 2);
790 : 4 : out_nulls = palloc(sizeof(bool) * count * 2);
791 : :
792 [ + + ]: 20 : for (i = 0; i < count; ++i)
793 : : {
794 [ + + ]: 16 : text *key = cstring_to_text_with_len(HSTORE_KEY(entries, base, i),
795 [ + + ]: 16 : HSTORE_KEYLEN(entries, i));
796 : :
797 : 16 : out_datums[i * 2] = PointerGetDatum(key);
798 : 16 : out_nulls[i * 2] = false;
799 : :
800 [ + + ]: 16 : if (HSTORE_VALISNULL(entries, i))
801 : : {
802 : 4 : out_datums[i * 2 + 1] = (Datum) 0;
803 : 4 : out_nulls[i * 2 + 1] = true;
804 : : }
805 : : else
806 : : {
807 [ + - ]: 12 : text *item = cstring_to_text_with_len(HSTORE_VAL(entries, base, i),
808 [ - + ]: 12 : HSTORE_VALLEN(entries, i));
809 : :
810 : 12 : out_datums[i * 2 + 1] = PointerGetDatum(item);
811 : 12 : out_nulls[i * 2 + 1] = false;
812 : : }
813 : : }
814 : :
815 : 4 : return construct_md_array(out_datums, out_nulls,
816 : : ndims, out_size, lb,
817 : : TEXTOID, -1, false, TYPALIGN_INT);
818 : : }
819 : :
820 : 8 : PG_FUNCTION_INFO_V1(hstore_to_array);
821 : : Datum
822 : 2 : hstore_to_array(PG_FUNCTION_ARGS)
823 : : {
824 : 2 : HStore *hs = PG_GETARG_HSTORE_P(0);
825 : 2 : ArrayType *out = hstore_to_array_internal(hs, 1);
826 : :
827 : 2 : PG_RETURN_POINTER(out);
828 : : }
829 : :
830 : 8 : PG_FUNCTION_INFO_V1(hstore_to_matrix);
831 : : Datum
832 : 2 : hstore_to_matrix(PG_FUNCTION_ARGS)
833 : : {
834 : 2 : HStore *hs = PG_GETARG_HSTORE_P(0);
835 : 2 : ArrayType *out = hstore_to_array_internal(hs, 2);
836 : :
837 : 2 : PG_RETURN_POINTER(out);
838 : : }
839 : :
840 : : /*
841 : : * Common initialization function for the various set-returning
842 : : * funcs. fcinfo is only passed if the function is to return a
843 : : * composite; it will be used to look up the return tupledesc.
844 : : * we stash a copy of the hstore in the multi-call context in
845 : : * case it was originally toasted. (At least I assume that's why;
846 : : * there was no explanatory comment in the original code. --AG)
847 : : */
848 : :
849 : : static void
850 : 2010 : setup_firstcall(FuncCallContext *funcctx, HStore *hs,
851 : : FunctionCallInfo fcinfo)
852 : : {
853 : : MemoryContext oldcontext;
854 : : HStore *st;
855 : :
856 : 2010 : oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
857 : :
858 : 2010 : st = (HStore *) palloc(VARSIZE(hs));
859 : 2010 : memcpy(st, hs, VARSIZE(hs));
860 : :
861 : 2010 : funcctx->user_fctx = st;
862 : :
863 [ + + ]: 2010 : if (fcinfo)
864 : : {
865 : : TupleDesc tupdesc;
866 : :
867 : : /* Build a tuple descriptor for our result type */
868 [ - + ]: 2003 : if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
869 [ # # ]: 0 : elog(ERROR, "return type must be a row type");
870 : :
871 : 2003 : funcctx->tuple_desc = BlessTupleDesc(tupdesc);
872 : : }
873 : :
874 : 2010 : MemoryContextSwitchTo(oldcontext);
875 : 2010 : }
876 : :
877 : :
878 : 8 : PG_FUNCTION_INFO_V1(hstore_skeys);
879 : : Datum
880 : 8 : hstore_skeys(PG_FUNCTION_ARGS)
881 : : {
882 : : FuncCallContext *funcctx;
883 : : HStore *hs;
884 : : int i;
885 : :
886 [ + + ]: 8 : if (SRF_IS_FIRSTCALL())
887 : : {
888 : 3 : hs = PG_GETARG_HSTORE_P(0);
889 : 3 : funcctx = SRF_FIRSTCALL_INIT();
890 : 3 : setup_firstcall(funcctx, hs, NULL);
891 : : }
892 : :
893 : 8 : funcctx = SRF_PERCALL_SETUP();
894 : 8 : hs = (HStore *) funcctx->user_fctx;
895 : 8 : i = funcctx->call_cntr;
896 : :
897 [ + + ]: 8 : if (i < HS_COUNT(hs))
898 : : {
899 : 5 : HEntry *entries = ARRPTR(hs);
900 : : text *item;
901 : :
902 [ + + ]: 5 : item = cstring_to_text_with_len(HSTORE_KEY(entries, STRPTR(hs), i),
903 [ + + ]: 5 : HSTORE_KEYLEN(entries, i));
904 : :
905 : 5 : SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
906 : : }
907 : :
908 : 3 : SRF_RETURN_DONE(funcctx);
909 : : }
910 : :
911 : :
912 : 8 : PG_FUNCTION_INFO_V1(hstore_svals);
913 : : Datum
914 : 13 : hstore_svals(PG_FUNCTION_ARGS)
915 : : {
916 : : FuncCallContext *funcctx;
917 : : HStore *hs;
918 : : int i;
919 : :
920 [ + + ]: 13 : if (SRF_IS_FIRSTCALL())
921 : : {
922 : 4 : hs = PG_GETARG_HSTORE_P(0);
923 : 4 : funcctx = SRF_FIRSTCALL_INIT();
924 : 4 : setup_firstcall(funcctx, hs, NULL);
925 : : }
926 : :
927 : 13 : funcctx = SRF_PERCALL_SETUP();
928 : 13 : hs = (HStore *) funcctx->user_fctx;
929 : 13 : i = funcctx->call_cntr;
930 : :
931 [ + + ]: 13 : if (i < HS_COUNT(hs))
932 : : {
933 : 9 : HEntry *entries = ARRPTR(hs);
934 : :
935 [ + + ]: 9 : if (HSTORE_VALISNULL(entries, i))
936 : : {
937 : : ReturnSetInfo *rsi;
938 : :
939 : : /* ugly ugly ugly. why no macro for this? */
940 : 1 : (funcctx)->call_cntr++;
941 : 1 : rsi = (ReturnSetInfo *) fcinfo->resultinfo;
942 : 1 : rsi->isDone = ExprMultipleResult;
943 : 1 : PG_RETURN_NULL();
944 : : }
945 : : else
946 : : {
947 : : text *item;
948 : :
949 [ + - ]: 8 : item = cstring_to_text_with_len(HSTORE_VAL(entries, STRPTR(hs), i),
950 [ - + ]: 8 : HSTORE_VALLEN(entries, i));
951 : :
952 : 8 : SRF_RETURN_NEXT(funcctx, PointerGetDatum(item));
953 : : }
954 : : }
955 : :
956 : 4 : SRF_RETURN_DONE(funcctx);
957 : : }
958 : :
959 : :
960 : 8 : PG_FUNCTION_INFO_V1(hstore_contains);
961 : : Datum
962 : 3560 : hstore_contains(PG_FUNCTION_ARGS)
963 : : {
964 : 3560 : HStore *val = PG_GETARG_HSTORE_P(0);
965 : 3560 : HStore *tmpl = PG_GETARG_HSTORE_P(1);
966 : 3560 : bool res = true;
967 : 3560 : HEntry *te = ARRPTR(tmpl);
968 : 3560 : char *tstr = STRPTR(tmpl);
969 : 3560 : HEntry *ve = ARRPTR(val);
970 : 3560 : char *vstr = STRPTR(val);
971 : 3560 : int tcount = HS_COUNT(tmpl);
972 : 3560 : int lastidx = 0;
973 : : int i;
974 : :
975 : : /*
976 : : * we exploit the fact that keys in "tmpl" are in strictly increasing
977 : : * order to narrow the hstoreFindKey search; each search can start one
978 : : * entry past the previous "found" entry, or at the lower bound of the
979 : : * search
980 : : */
981 : :
982 [ + + + + ]: 7148 : for (i = 0; res && i < tcount; ++i)
983 : : {
984 : 3588 : int idx = hstoreFindKey(val, &lastidx,
985 [ + + ]: 3588 : HSTORE_KEY(te, tstr, i),
986 [ + + ]: 3588 : HSTORE_KEYLEN(te, i));
987 : :
988 [ + + ]: 3588 : if (idx >= 0)
989 : : {
990 : 1083 : bool nullval = HSTORE_VALISNULL(te, i);
991 [ - + ]: 1083 : int vallen = HSTORE_VALLEN(te, i);
992 : :
993 [ + + ]: 1083 : if (nullval != HSTORE_VALISNULL(ve, idx) ||
994 [ + + - + : 513 : (!nullval && (vallen != HSTORE_VALLEN(ve, idx) ||
+ + ]
995 [ + + ]: 305 : memcmp(HSTORE_VAL(te, tstr, i),
996 [ + - + - ]: 305 : HSTORE_VAL(ve, vstr, idx),
997 : : vallen) != 0)))
998 : 980 : res = false;
999 : : }
1000 : : else
1001 : 2505 : res = false;
1002 : : }
1003 : :
1004 : 3560 : PG_RETURN_BOOL(res);
1005 : : }
1006 : :
1007 : :
1008 : 7 : PG_FUNCTION_INFO_V1(hstore_contained);
1009 : : Datum
1010 : 0 : hstore_contained(PG_FUNCTION_ARGS)
1011 : : {
1012 : 0 : PG_RETURN_DATUM(DirectFunctionCall2(hstore_contains,
1013 : : PG_GETARG_DATUM(1),
1014 : : PG_GETARG_DATUM(0)
1015 : : ));
1016 : : }
1017 : :
1018 : :
1019 : 8 : PG_FUNCTION_INFO_V1(hstore_each);
1020 : : Datum
1021 : 11568 : hstore_each(PG_FUNCTION_ARGS)
1022 : : {
1023 : : FuncCallContext *funcctx;
1024 : : HStore *hs;
1025 : : int i;
1026 : :
1027 [ + + ]: 11568 : if (SRF_IS_FIRSTCALL())
1028 : : {
1029 : 2003 : hs = PG_GETARG_HSTORE_P(0);
1030 : 2003 : funcctx = SRF_FIRSTCALL_INIT();
1031 : 2003 : setup_firstcall(funcctx, hs, fcinfo);
1032 : : }
1033 : :
1034 : 11568 : funcctx = SRF_PERCALL_SETUP();
1035 : 11568 : hs = (HStore *) funcctx->user_fctx;
1036 : 11568 : i = funcctx->call_cntr;
1037 : :
1038 [ + + ]: 11568 : if (i < HS_COUNT(hs))
1039 : : {
1040 : 9565 : HEntry *entries = ARRPTR(hs);
1041 : 9565 : char *ptr = STRPTR(hs);
1042 : : Datum res,
1043 : : dvalues[2];
1044 : 9565 : bool nulls[2] = {false, false};
1045 : : text *item;
1046 : : HeapTuple tuple;
1047 : :
1048 [ + + ]: 9565 : item = cstring_to_text_with_len(HSTORE_KEY(entries, ptr, i),
1049 [ + + ]: 9565 : HSTORE_KEYLEN(entries, i));
1050 : 9565 : dvalues[0] = PointerGetDatum(item);
1051 : :
1052 [ + + ]: 9565 : if (HSTORE_VALISNULL(entries, i))
1053 : : {
1054 : 3 : dvalues[1] = (Datum) 0;
1055 : 3 : nulls[1] = true;
1056 : : }
1057 : : else
1058 : : {
1059 [ + - ]: 9562 : item = cstring_to_text_with_len(HSTORE_VAL(entries, ptr, i),
1060 [ - + ]: 9562 : HSTORE_VALLEN(entries, i));
1061 : 9562 : dvalues[1] = PointerGetDatum(item);
1062 : : }
1063 : :
1064 : 9565 : tuple = heap_form_tuple(funcctx->tuple_desc, dvalues, nulls);
1065 : 9565 : res = HeapTupleGetDatum(tuple);
1066 : :
1067 : 9565 : SRF_RETURN_NEXT(funcctx, res);
1068 : : }
1069 : :
1070 : 2003 : SRF_RETURN_DONE(funcctx);
1071 : : }
1072 : :
1073 : :
1074 : : /*
1075 : : * btree sort order for hstores isn't intended to be useful; we really only
1076 : : * care about equality versus non-equality. we compare the entire string
1077 : : * buffer first, then the entry pos array.
1078 : : */
1079 : :
1080 : 8 : PG_FUNCTION_INFO_V1(hstore_cmp);
1081 : : Datum
1082 : 43142 : hstore_cmp(PG_FUNCTION_ARGS)
1083 : : {
1084 : 43142 : HStore *hs1 = PG_GETARG_HSTORE_P(0);
1085 : 43142 : HStore *hs2 = PG_GETARG_HSTORE_P(1);
1086 : 43142 : int hcount1 = HS_COUNT(hs1);
1087 : 43142 : int hcount2 = HS_COUNT(hs2);
1088 : 43142 : int res = 0;
1089 : :
1090 [ + + + + ]: 43142 : if (hcount1 == 0 || hcount2 == 0)
1091 : : {
1092 : : /*
1093 : : * if either operand is empty, and the other is nonempty, the nonempty
1094 : : * one is larger. If both are empty they are equal.
1095 : : */
1096 [ + + ]: 3676 : if (hcount1 > 0)
1097 : 253 : res = 1;
1098 [ + + ]: 3423 : else if (hcount2 > 0)
1099 : 1635 : res = -1;
1100 : : }
1101 : : else
1102 : : {
1103 : : /* here we know both operands are nonempty */
1104 : 39466 : char *str1 = STRPTR(hs1);
1105 : 39466 : char *str2 = STRPTR(hs2);
1106 : 39466 : HEntry *ent1 = ARRPTR(hs1);
1107 : 39466 : HEntry *ent2 = ARRPTR(hs2);
1108 : 39466 : size_t len1 = HSE_ENDPOS(ent1[2 * hcount1 - 1]);
1109 : 39466 : size_t len2 = HSE_ENDPOS(ent2[2 * hcount2 - 1]);
1110 : :
1111 : 39466 : res = memcmp(str1, str2, Min(len1, len2));
1112 : :
1113 [ + + ]: 39466 : if (res == 0)
1114 : : {
1115 [ - + ]: 2770 : if (len1 > len2)
1116 : 0 : res = 1;
1117 [ - + ]: 2770 : else if (len1 < len2)
1118 : 0 : res = -1;
1119 [ - + ]: 2770 : else if (hcount1 > hcount2)
1120 : 0 : res = 1;
1121 [ - + ]: 2770 : else if (hcount2 > hcount1)
1122 : 0 : res = -1;
1123 : : else
1124 : : {
1125 : 2770 : int count = hcount1 * 2;
1126 : : int i;
1127 : :
1128 [ + + ]: 32770 : for (i = 0; i < count; ++i)
1129 [ + - ]: 30000 : if (HSE_ENDPOS(ent1[i]) != HSE_ENDPOS(ent2[i]) ||
1130 [ + - ]: 30000 : HSE_ISNULL(ent1[i]) != HSE_ISNULL(ent2[i]))
1131 : : break;
1132 [ - + ]: 2770 : if (i < count)
1133 : : {
1134 [ # # ]: 0 : if (HSE_ENDPOS(ent1[i]) < HSE_ENDPOS(ent2[i]))
1135 : 0 : res = -1;
1136 [ # # ]: 0 : else if (HSE_ENDPOS(ent1[i]) > HSE_ENDPOS(ent2[i]))
1137 : 0 : res = 1;
1138 [ # # ]: 0 : else if (HSE_ISNULL(ent1[i]))
1139 : 0 : res = 1;
1140 [ # # ]: 0 : else if (HSE_ISNULL(ent2[i]))
1141 : 0 : res = -1;
1142 : : }
1143 : : }
1144 : : }
1145 : : else
1146 : : {
1147 [ + + ]: 36696 : res = (res > 0) ? 1 : -1;
1148 : : }
1149 : : }
1150 : :
1151 : : /*
1152 : : * this is a btree support function; this is one of the few places where
1153 : : * memory needs to be explicitly freed.
1154 : : */
1155 [ + + ]: 43142 : PG_FREE_IF_COPY(hs1, 0);
1156 [ + + ]: 43142 : PG_FREE_IF_COPY(hs2, 1);
1157 : 43142 : PG_RETURN_INT32(res);
1158 : : }
1159 : :
1160 : :
1161 : 8 : PG_FUNCTION_INFO_V1(hstore_eq);
1162 : : Datum
1163 : 4121 : hstore_eq(PG_FUNCTION_ARGS)
1164 : : {
1165 : 4121 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1166 : : PG_GETARG_DATUM(0),
1167 : : PG_GETARG_DATUM(1)));
1168 : :
1169 : 4121 : PG_RETURN_BOOL(res == 0);
1170 : : }
1171 : :
1172 : 7 : PG_FUNCTION_INFO_V1(hstore_ne);
1173 : : Datum
1174 : 0 : hstore_ne(PG_FUNCTION_ARGS)
1175 : : {
1176 : 0 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1177 : : PG_GETARG_DATUM(0),
1178 : : PG_GETARG_DATUM(1)));
1179 : :
1180 : 0 : PG_RETURN_BOOL(res != 0);
1181 : : }
1182 : :
1183 : 8 : PG_FUNCTION_INFO_V1(hstore_gt);
1184 : : Datum
1185 : 8 : hstore_gt(PG_FUNCTION_ARGS)
1186 : : {
1187 : 8 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1188 : : PG_GETARG_DATUM(0),
1189 : : PG_GETARG_DATUM(1)));
1190 : :
1191 : 8 : PG_RETURN_BOOL(res > 0);
1192 : : }
1193 : :
1194 : 7 : PG_FUNCTION_INFO_V1(hstore_ge);
1195 : : Datum
1196 : 0 : hstore_ge(PG_FUNCTION_ARGS)
1197 : : {
1198 : 0 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1199 : : PG_GETARG_DATUM(0),
1200 : : PG_GETARG_DATUM(1)));
1201 : :
1202 : 0 : PG_RETURN_BOOL(res >= 0);
1203 : : }
1204 : :
1205 : 7 : PG_FUNCTION_INFO_V1(hstore_lt);
1206 : : Datum
1207 : 0 : hstore_lt(PG_FUNCTION_ARGS)
1208 : : {
1209 : 0 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1210 : : PG_GETARG_DATUM(0),
1211 : : PG_GETARG_DATUM(1)));
1212 : :
1213 : 0 : PG_RETURN_BOOL(res < 0);
1214 : : }
1215 : :
1216 : 7 : PG_FUNCTION_INFO_V1(hstore_le);
1217 : : Datum
1218 : 0 : hstore_le(PG_FUNCTION_ARGS)
1219 : : {
1220 : 0 : int res = DatumGetInt32(DirectFunctionCall2(hstore_cmp,
1221 : : PG_GETARG_DATUM(0),
1222 : : PG_GETARG_DATUM(1)));
1223 : :
1224 : 0 : PG_RETURN_BOOL(res <= 0);
1225 : : }
1226 : :
1227 : :
1228 : 8 : PG_FUNCTION_INFO_V1(hstore_hash);
1229 : : Datum
1230 : 2014 : hstore_hash(PG_FUNCTION_ARGS)
1231 : : {
1232 : 2014 : HStore *hs = PG_GETARG_HSTORE_P(0);
1233 : 2014 : Datum hval = hash_any((unsigned char *) VARDATA(hs),
1234 : 2014 : VARSIZE(hs) - VARHDRSZ);
1235 : :
1236 : : /*
1237 : : * This (along with hstore_hash_extended) is the only place in the code
1238 : : * that cares whether the overall varlena size exactly matches the true
1239 : : * data size; this assertion should be maintained by all the other code,
1240 : : * but we make it explicit here.
1241 : : */
1242 : : Assert(VARSIZE(hs) ==
1243 : : (HS_COUNT(hs) != 0 ?
1244 : : CALCDATASIZE(HS_COUNT(hs),
1245 : : HSE_ENDPOS(ARRPTR(hs)[2 * HS_COUNT(hs) - 1])) :
1246 : : HSHRDSIZE));
1247 : :
1248 [ + + ]: 2014 : PG_FREE_IF_COPY(hs, 0);
1249 : 2014 : PG_RETURN_DATUM(hval);
1250 : : }
1251 : :
1252 : 8 : PG_FUNCTION_INFO_V1(hstore_hash_extended);
1253 : : Datum
1254 : 10 : hstore_hash_extended(PG_FUNCTION_ARGS)
1255 : : {
1256 : 10 : HStore *hs = PG_GETARG_HSTORE_P(0);
1257 : 10 : uint64 seed = PG_GETARG_INT64(1);
1258 : : Datum hval;
1259 : :
1260 : 10 : hval = hash_any_extended((unsigned char *) VARDATA(hs),
1261 : 10 : VARSIZE(hs) - VARHDRSZ,
1262 : : seed);
1263 : :
1264 : : /* See comment in hstore_hash */
1265 : : Assert(VARSIZE(hs) ==
1266 : : (HS_COUNT(hs) != 0 ?
1267 : : CALCDATASIZE(HS_COUNT(hs),
1268 : : HSE_ENDPOS(ARRPTR(hs)[2 * HS_COUNT(hs) - 1])) :
1269 : : HSHRDSIZE));
1270 : :
1271 [ - + ]: 10 : PG_FREE_IF_COPY(hs, 0);
1272 : 10 : PG_RETURN_DATUM(hval);
1273 : : }
|
