Line data Source code
1 : /*
2 : * contrib/hstore/hstore_io.c
3 : */
4 : #include "postgres.h"
5 :
6 : #include <ctype.h>
7 :
8 : #include "access/htup_details.h"
9 : #include "catalog/pg_type.h"
10 : #include "common/jsonapi.h"
11 : #include "funcapi.h"
12 : #include "hstore.h"
13 : #include "lib/stringinfo.h"
14 : #include "libpq/pqformat.h"
15 : #include "nodes/miscnodes.h"
16 : #include "parser/scansup.h"
17 : #include "utils/builtins.h"
18 : #include "utils/json.h"
19 : #include "utils/jsonb.h"
20 : #include "utils/lsyscache.h"
21 : #include "utils/memutils.h"
22 : #include "utils/typcache.h"
23 :
24 18 : PG_MODULE_MAGIC_EXT(
25 : .name = "hstore",
26 : .version = PG_VERSION
27 : );
28 :
29 : /* old names for C functions */
30 0 : HSTORE_POLLUTE(hstore_from_text, tconvert);
31 :
32 :
33 : typedef struct
34 : {
35 : char *begin;
36 : char *ptr;
37 : char *cur;
38 : char *word;
39 : int wordlen;
40 : Node *escontext;
41 :
42 : Pairs *pairs;
43 : int pcur;
44 : int plen;
45 : } HSParser;
46 :
47 : static bool hstoreCheckKeyLength(size_t len, HSParser *state);
48 : static bool hstoreCheckValLength(size_t len, HSParser *state);
49 :
50 :
51 : #define RESIZEPRSBUF \
52 : do { \
53 : if ( state->cur - state->word + 1 >= state->wordlen ) \
54 : { \
55 : int32 clen = state->cur - state->word; \
56 : state->wordlen *= 2; \
57 : state->word = (char*)repalloc( (void*)state->word, state->wordlen ); \
58 : state->cur = state->word + clen; \
59 : } \
60 : } while (0)
61 :
62 : #define PRSSYNTAXERROR return prssyntaxerror(state)
63 :
64 : static bool
65 4 : prssyntaxerror(HSParser *state)
66 : {
67 4 : errsave(state->escontext,
68 : (errcode(ERRCODE_SYNTAX_ERROR),
69 : errmsg("syntax error in hstore, near \"%.*s\" at position %d",
70 : pg_mblen_cstr(state->ptr), state->ptr,
71 : (int) (state->ptr - state->begin))));
72 : /* In soft error situation, return false as convenience for caller */
73 3 : return false;
74 : }
75 :
76 : #define PRSEOF return prseof(state)
77 :
78 : static bool
79 1 : prseof(HSParser *state)
80 : {
81 1 : errsave(state->escontext,
82 : (errcode(ERRCODE_SYNTAX_ERROR),
83 : errmsg("syntax error in hstore: unexpected end of string")));
84 : /* In soft error situation, return false as convenience for caller */
85 0 : return false;
86 : }
87 :
88 :
89 : #define GV_WAITVAL 0
90 : #define GV_INVAL 1
91 : #define GV_INESCVAL 2
92 : #define GV_WAITESCIN 3
93 : #define GV_WAITESCESCIN 4
94 :
95 : static bool
96 10834 : get_val(HSParser *state, bool ignoreeq, bool *escaped)
97 : {
98 10834 : int st = GV_WAITVAL;
99 :
100 10834 : state->wordlen = 32;
101 10834 : state->cur = state->word = palloc(state->wordlen);
102 10834 : *escaped = false;
103 :
104 : while (1)
105 : {
106 52135 : if (st == GV_WAITVAL)
107 : {
108 15097 : if (*(state->ptr) == '"')
109 : {
110 89 : *escaped = true;
111 89 : st = GV_INESCVAL;
112 : }
113 15008 : else if (*(state->ptr) == '\0')
114 : {
115 146 : return false;
116 : }
117 14862 : else if (*(state->ptr) == '=' && !ignoreeq)
118 : {
119 2 : PRSSYNTAXERROR;
120 : }
121 14860 : else if (*(state->ptr) == '\\')
122 : {
123 2 : st = GV_WAITESCIN;
124 : }
125 14858 : else if (!scanner_isspace((unsigned char) *(state->ptr)))
126 : {
127 10595 : *(state->cur) = *(state->ptr);
128 10595 : state->cur++;
129 10595 : st = GV_INVAL;
130 : }
131 : }
132 37038 : else if (st == GV_INVAL)
133 : {
134 36637 : if (*(state->ptr) == '\\')
135 : {
136 1 : st = GV_WAITESCIN;
137 : }
138 36636 : else if (*(state->ptr) == '=' && !ignoreeq)
139 : {
140 5265 : state->ptr--;
141 5265 : return true;
142 : }
143 31371 : else if (*(state->ptr) == ',' && ignoreeq)
144 : {
145 4131 : state->ptr--;
146 4131 : return true;
147 : }
148 27240 : else if (scanner_isspace((unsigned char) *(state->ptr)))
149 : {
150 100 : return true;
151 : }
152 27140 : else if (*(state->ptr) == '\0')
153 : {
154 1101 : state->ptr--;
155 1101 : return true;
156 : }
157 : else
158 : {
159 26039 : RESIZEPRSBUF;
160 26039 : *(state->cur) = *(state->ptr);
161 26039 : state->cur++;
162 : }
163 : }
164 401 : else if (st == GV_INESCVAL)
165 : {
166 397 : if (*(state->ptr) == '\\')
167 : {
168 1 : st = GV_WAITESCESCIN;
169 : }
170 396 : else if (*(state->ptr) == '"')
171 : {
172 88 : return true;
173 : }
174 308 : else if (*(state->ptr) == '\0')
175 : {
176 1 : PRSEOF;
177 : }
178 : else
179 : {
180 307 : RESIZEPRSBUF;
181 307 : *(state->cur) = *(state->ptr);
182 307 : state->cur++;
183 : }
184 : }
185 4 : else if (st == GV_WAITESCIN)
186 : {
187 3 : if (*(state->ptr) == '\0')
188 0 : PRSEOF;
189 3 : RESIZEPRSBUF;
190 3 : *(state->cur) = *(state->ptr);
191 3 : state->cur++;
192 3 : st = GV_INVAL;
193 : }
194 1 : else if (st == GV_WAITESCESCIN)
195 : {
196 1 : if (*(state->ptr) == '\0')
197 0 : PRSEOF;
198 1 : RESIZEPRSBUF;
199 1 : *(state->cur) = *(state->ptr);
200 1 : state->cur++;
201 1 : st = GV_INESCVAL;
202 : }
203 : else
204 0 : elog(ERROR, "unrecognized get_val state: %d", st);
205 :
206 41301 : state->ptr++;
207 : }
208 : }
209 :
210 : #define WKEY 0
211 : #define WVAL 1
212 : #define WEQ 2
213 : #define WGT 3
214 : #define WDEL 4
215 :
216 :
217 : static bool
218 1290 : parse_hstore(HSParser *state)
219 : {
220 1290 : int st = WKEY;
221 1290 : bool escaped = false;
222 :
223 1290 : state->plen = 16;
224 1290 : state->pairs = palloc_array(Pairs, state->plen);
225 1290 : state->pcur = 0;
226 1290 : state->ptr = state->begin;
227 1290 : state->word = NULL;
228 :
229 : while (1)
230 : {
231 26878 : if (st == WKEY)
232 : {
233 5492 : if (!get_val(state, false, &escaped))
234 : {
235 147 : if (SOFT_ERROR_OCCURRED(state->escontext))
236 1 : return false;
237 146 : return true; /* EOF, all okay */
238 : }
239 5344 : if (state->pcur >= state->plen)
240 : {
241 0 : state->plen *= 2;
242 0 : state->pairs = (Pairs *) repalloc(state->pairs, sizeof(Pairs) * state->plen);
243 : }
244 5344 : if (!hstoreCheckKeyLength(state->cur - state->word, state))
245 0 : return false;
246 5344 : state->pairs[state->pcur].key = state->word;
247 5344 : state->pairs[state->pcur].keylen = state->cur - state->word;
248 5344 : state->pairs[state->pcur].val = NULL;
249 5344 : state->word = NULL;
250 5344 : st = WEQ;
251 : }
252 21386 : else if (st == WEQ)
253 : {
254 5355 : if (*(state->ptr) == '=')
255 : {
256 5344 : st = WGT;
257 : }
258 11 : else if (*(state->ptr) == '\0')
259 : {
260 0 : PRSEOF;
261 : }
262 11 : else if (!scanner_isspace((unsigned char) *(state->ptr)))
263 : {
264 0 : PRSSYNTAXERROR;
265 : }
266 : }
267 16031 : else if (st == WGT)
268 : {
269 5344 : if (*(state->ptr) == '>')
270 : {
271 5342 : st = WVAL;
272 : }
273 2 : else if (*(state->ptr) == '\0')
274 : {
275 0 : PRSEOF;
276 : }
277 : else
278 : {
279 2 : PRSSYNTAXERROR;
280 : }
281 : }
282 10687 : else if (st == WVAL)
283 : {
284 5342 : if (!get_val(state, true, &escaped))
285 : {
286 0 : if (SOFT_ERROR_OCCURRED(state->escontext))
287 0 : return false;
288 0 : PRSEOF;
289 : }
290 5341 : if (!hstoreCheckValLength(state->cur - state->word, state))
291 0 : return false;
292 5341 : state->pairs[state->pcur].val = state->word;
293 5341 : state->pairs[state->pcur].vallen = state->cur - state->word;
294 5341 : state->pairs[state->pcur].isnull = false;
295 5341 : state->pairs[state->pcur].needfree = true;
296 5341 : if (state->cur - state->word == 4 && !escaped)
297 : {
298 73 : state->word[4] = '\0';
299 73 : if (pg_strcasecmp(state->word, "null") == 0)
300 69 : state->pairs[state->pcur].isnull = true;
301 : }
302 5341 : state->word = NULL;
303 5341 : state->pcur++;
304 5341 : st = WDEL;
305 : }
306 5345 : else if (st == WDEL)
307 : {
308 5345 : if (*(state->ptr) == ',')
309 : {
310 4202 : st = WKEY;
311 : }
312 1143 : else if (*(state->ptr) == '\0')
313 : {
314 1139 : return true;
315 : }
316 4 : else if (!scanner_isspace((unsigned char) *(state->ptr)))
317 : {
318 0 : PRSSYNTAXERROR;
319 : }
320 : }
321 : else
322 0 : elog(ERROR, "unrecognized parse_hstore state: %d", st);
323 :
324 25588 : state->ptr++;
325 : }
326 : }
327 :
328 : static int
329 12690 : comparePairs(const void *a, const void *b)
330 : {
331 12690 : const Pairs *pa = a;
332 12690 : const Pairs *pb = b;
333 :
334 12690 : if (pa->keylen == pb->keylen)
335 : {
336 2530 : int res = memcmp(pa->key, pb->key, pa->keylen);
337 :
338 2530 : if (res)
339 2530 : return res;
340 :
341 : /* guarantee that needfree will be later */
342 0 : if (pb->needfree == pa->needfree)
343 0 : return 0;
344 0 : else if (pa->needfree)
345 0 : return 1;
346 : else
347 0 : return -1;
348 : }
349 10160 : return (pa->keylen > pb->keylen) ? 1 : -1;
350 : }
351 :
352 : /*
353 : * this code still respects pairs.needfree, even though in general
354 : * it should never be called in a context where anything needs freeing.
355 : * we keep it because (a) those calls are in a rare code path anyway,
356 : * and (b) who knows whether they might be needed by some caller.
357 : */
358 : int
359 4153 : hstoreUniquePairs(Pairs *a, int32 l, int32 *buflen)
360 : {
361 : Pairs *ptr,
362 : *res;
363 :
364 4153 : *buflen = 0;
365 4153 : if (l < 2)
366 : {
367 239 : if (l == 1)
368 91 : *buflen = a->keylen + ((a->isnull) ? 0 : a->vallen);
369 239 : return l;
370 : }
371 :
372 3914 : qsort(a, l, sizeof(Pairs), comparePairs);
373 :
374 : /*
375 : * We can't use qunique here because we have some clean-up code to run on
376 : * removed elements.
377 : */
378 3914 : ptr = a + 1;
379 3914 : res = a;
380 11022 : while (ptr - a < l)
381 : {
382 7108 : if (ptr->keylen == res->keylen &&
383 1874 : memcmp(ptr->key, res->key, res->keylen) == 0)
384 : {
385 0 : if (ptr->needfree)
386 : {
387 0 : pfree(ptr->key);
388 0 : if (ptr->val != NULL)
389 0 : pfree(ptr->val);
390 : }
391 : }
392 : else
393 : {
394 7108 : *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen);
395 7108 : res++;
396 7108 : if (res != ptr)
397 0 : memcpy(res, ptr, sizeof(Pairs));
398 : }
399 :
400 7108 : ptr++;
401 : }
402 :
403 3914 : *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen);
404 3914 : return res + 1 - a;
405 : }
406 :
407 : size_t
408 135 : hstoreCheckKeyLen(size_t len)
409 : {
410 135 : if (len > HSTORE_MAX_KEY_LEN)
411 0 : ereport(ERROR,
412 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
413 : errmsg("string too long for hstore key")));
414 135 : return len;
415 : }
416 :
417 : static bool
418 5344 : hstoreCheckKeyLength(size_t len, HSParser *state)
419 : {
420 5344 : if (len > HSTORE_MAX_KEY_LEN)
421 0 : ereturn(state->escontext, false,
422 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
423 : errmsg("string too long for hstore key")));
424 5344 : return true;
425 : }
426 :
427 : size_t
428 98 : hstoreCheckValLen(size_t len)
429 : {
430 98 : if (len > HSTORE_MAX_VALUE_LEN)
431 0 : ereport(ERROR,
432 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
433 : errmsg("string too long for hstore value")));
434 98 : return len;
435 : }
436 :
437 : static bool
438 5341 : hstoreCheckValLength(size_t len, HSParser *state)
439 : {
440 5341 : if (len > HSTORE_MAX_VALUE_LEN)
441 0 : ereturn(state->escontext, false,
442 : (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
443 : errmsg("string too long for hstore value")));
444 5341 : return true;
445 : }
446 :
447 :
448 : HStore *
449 1361 : hstorePairs(Pairs *pairs, int32 pcount, int32 buflen)
450 : {
451 : HStore *out;
452 : HEntry *entry;
453 : char *ptr;
454 : char *buf;
455 : int32 len;
456 : int32 i;
457 :
458 1361 : len = CALCDATASIZE(pcount, buflen);
459 1361 : out = palloc(len);
460 1361 : SET_VARSIZE(out, len);
461 1361 : HS_SETCOUNT(out, pcount);
462 :
463 1361 : if (pcount == 0)
464 151 : return out;
465 :
466 1210 : entry = ARRPTR(out);
467 1210 : buf = ptr = STRPTR(out);
468 :
469 6693 : for (i = 0; i < pcount; i++)
470 5483 : HS_ADDITEM(entry, buf, ptr, pairs[i]);
471 :
472 1210 : HS_FINALIZE(out, pcount, buf, ptr);
473 :
474 1210 : return out;
475 : }
476 :
477 :
478 16 : PG_FUNCTION_INFO_V1(hstore_in);
479 : Datum
480 1290 : hstore_in(PG_FUNCTION_ARGS)
481 : {
482 1290 : char *str = PG_GETARG_CSTRING(0);
483 1290 : Node *escontext = fcinfo->context;
484 : HSParser state;
485 : int32 buflen;
486 : HStore *out;
487 :
488 1290 : state.begin = str;
489 1290 : state.escontext = escontext;
490 :
491 1290 : if (!parse_hstore(&state))
492 3 : PG_RETURN_NULL();
493 :
494 1285 : state.pcur = hstoreUniquePairs(state.pairs, state.pcur, &buflen);
495 :
496 1285 : out = hstorePairs(state.pairs, state.pcur, buflen);
497 :
498 1285 : PG_RETURN_POINTER(out);
499 : }
500 :
501 :
502 8 : PG_FUNCTION_INFO_V1(hstore_recv);
503 : Datum
504 0 : hstore_recv(PG_FUNCTION_ARGS)
505 : {
506 : int32 buflen;
507 : HStore *out;
508 : Pairs *pairs;
509 : int32 i;
510 : int32 pcount;
511 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
512 :
513 0 : pcount = pq_getmsgint(buf, 4);
514 :
515 0 : if (pcount == 0)
516 : {
517 0 : out = hstorePairs(NULL, 0, 0);
518 0 : PG_RETURN_POINTER(out);
519 : }
520 :
521 0 : if (pcount < 0 || pcount > MaxAllocSize / sizeof(Pairs))
522 0 : ereport(ERROR,
523 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
524 : errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
525 : pcount, (int) (MaxAllocSize / sizeof(Pairs)))));
526 0 : pairs = palloc(pcount * sizeof(Pairs));
527 :
528 0 : for (i = 0; i < pcount; ++i)
529 : {
530 0 : int rawlen = pq_getmsgint(buf, 4);
531 : int len;
532 :
533 0 : if (rawlen < 0)
534 0 : ereport(ERROR,
535 : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
536 : errmsg("null value not allowed for hstore key")));
537 :
538 0 : pairs[i].key = pq_getmsgtext(buf, rawlen, &len);
539 0 : pairs[i].keylen = hstoreCheckKeyLen(len);
540 0 : pairs[i].needfree = true;
541 :
542 0 : rawlen = pq_getmsgint(buf, 4);
543 0 : if (rawlen < 0)
544 : {
545 0 : pairs[i].val = NULL;
546 0 : pairs[i].vallen = 0;
547 0 : pairs[i].isnull = true;
548 : }
549 : else
550 : {
551 0 : pairs[i].val = pq_getmsgtext(buf, rawlen, &len);
552 0 : pairs[i].vallen = hstoreCheckValLen(len);
553 0 : pairs[i].isnull = false;
554 : }
555 : }
556 :
557 0 : pcount = hstoreUniquePairs(pairs, pcount, &buflen);
558 :
559 0 : out = hstorePairs(pairs, pcount, buflen);
560 :
561 0 : PG_RETURN_POINTER(out);
562 : }
563 :
564 :
565 15 : PG_FUNCTION_INFO_V1(hstore_from_text);
566 : Datum
567 36 : hstore_from_text(PG_FUNCTION_ARGS)
568 : {
569 : text *key;
570 36 : text *val = NULL;
571 : Pairs p;
572 : HStore *out;
573 :
574 36 : if (PG_ARGISNULL(0))
575 1 : PG_RETURN_NULL();
576 :
577 35 : p.needfree = false;
578 35 : key = PG_GETARG_TEXT_PP(0);
579 35 : p.key = VARDATA_ANY(key);
580 35 : p.keylen = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key));
581 :
582 35 : if (PG_ARGISNULL(1))
583 : {
584 8 : p.vallen = 0;
585 8 : p.isnull = true;
586 : }
587 : else
588 : {
589 27 : val = PG_GETARG_TEXT_PP(1);
590 27 : p.val = VARDATA_ANY(val);
591 27 : p.vallen = hstoreCheckValLen(VARSIZE_ANY_EXHDR(val));
592 27 : p.isnull = false;
593 : }
594 :
595 35 : out = hstorePairs(&p, 1, p.keylen + p.vallen);
596 :
597 35 : PG_RETURN_POINTER(out);
598 : }
599 :
600 :
601 8 : PG_FUNCTION_INFO_V1(hstore_from_arrays);
602 : Datum
603 10 : hstore_from_arrays(PG_FUNCTION_ARGS)
604 : {
605 : int32 buflen;
606 : HStore *out;
607 : Pairs *pairs;
608 : Datum *key_datums;
609 : bool *key_nulls;
610 : int key_count;
611 : Datum *value_datums;
612 : bool *value_nulls;
613 : int value_count;
614 : ArrayType *key_array;
615 : ArrayType *value_array;
616 : int i;
617 :
618 10 : if (PG_ARGISNULL(0))
619 0 : PG_RETURN_NULL();
620 :
621 10 : key_array = PG_GETARG_ARRAYTYPE_P(0);
622 :
623 : Assert(ARR_ELEMTYPE(key_array) == TEXTOID);
624 :
625 : /*
626 : * must check >1 rather than != 1 because empty arrays have 0 dimensions,
627 : * not 1
628 : */
629 :
630 10 : if (ARR_NDIM(key_array) > 1)
631 0 : ereport(ERROR,
632 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
633 : errmsg("wrong number of array subscripts")));
634 :
635 10 : deconstruct_array_builtin(key_array, TEXTOID, &key_datums, &key_nulls, &key_count);
636 :
637 : /* see discussion in hstoreArrayToPairs() */
638 10 : if (key_count > MaxAllocSize / sizeof(Pairs))
639 0 : ereport(ERROR,
640 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
641 : errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
642 : key_count, (int) (MaxAllocSize / sizeof(Pairs)))));
643 :
644 : /* value_array might be NULL */
645 :
646 10 : if (PG_ARGISNULL(1))
647 : {
648 2 : value_array = NULL;
649 2 : value_count = key_count;
650 2 : value_datums = NULL;
651 2 : value_nulls = NULL;
652 : }
653 : else
654 : {
655 8 : value_array = PG_GETARG_ARRAYTYPE_P(1);
656 :
657 : Assert(ARR_ELEMTYPE(value_array) == TEXTOID);
658 :
659 8 : if (ARR_NDIM(value_array) > 1)
660 0 : ereport(ERROR,
661 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
662 : errmsg("wrong number of array subscripts")));
663 :
664 8 : if ((ARR_NDIM(key_array) > 0 || ARR_NDIM(value_array) > 0) &&
665 7 : (ARR_NDIM(key_array) != ARR_NDIM(value_array) ||
666 5 : ARR_DIMS(key_array)[0] != ARR_DIMS(value_array)[0] ||
667 5 : ARR_LBOUND(key_array)[0] != ARR_LBOUND(value_array)[0]))
668 2 : ereport(ERROR,
669 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
670 : errmsg("arrays must have same bounds")));
671 :
672 6 : deconstruct_array_builtin(value_array, TEXTOID, &value_datums, &value_nulls, &value_count);
673 :
674 : Assert(key_count == value_count);
675 : }
676 :
677 8 : pairs = palloc(key_count * sizeof(Pairs));
678 :
679 28 : for (i = 0; i < key_count; ++i)
680 : {
681 20 : if (key_nulls[i])
682 0 : ereport(ERROR,
683 : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
684 : errmsg("null value not allowed for hstore key")));
685 :
686 20 : if (!value_nulls || value_nulls[i])
687 : {
688 9 : pairs[i].key = VARDATA(DatumGetPointer(key_datums[i]));
689 9 : pairs[i].val = NULL;
690 18 : pairs[i].keylen =
691 9 : hstoreCheckKeyLen(VARSIZE(DatumGetPointer(key_datums[i])) - VARHDRSZ);
692 9 : pairs[i].vallen = 4;
693 9 : pairs[i].isnull = true;
694 9 : pairs[i].needfree = false;
695 : }
696 : else
697 : {
698 11 : pairs[i].key = VARDATA(DatumGetPointer(key_datums[i]));
699 11 : pairs[i].val = VARDATA(DatumGetPointer(value_datums[i]));
700 22 : pairs[i].keylen =
701 11 : hstoreCheckKeyLen(VARSIZE(DatumGetPointer(key_datums[i])) - VARHDRSZ);
702 22 : pairs[i].vallen =
703 11 : hstoreCheckValLen(VARSIZE(DatumGetPointer(value_datums[i])) - VARHDRSZ);
704 11 : pairs[i].isnull = false;
705 11 : pairs[i].needfree = false;
706 : }
707 : }
708 :
709 8 : key_count = hstoreUniquePairs(pairs, key_count, &buflen);
710 :
711 8 : out = hstorePairs(pairs, key_count, buflen);
712 :
713 8 : PG_RETURN_POINTER(out);
714 : }
715 :
716 :
717 8 : PG_FUNCTION_INFO_V1(hstore_from_array);
718 : Datum
719 14 : hstore_from_array(PG_FUNCTION_ARGS)
720 : {
721 14 : ArrayType *in_array = PG_GETARG_ARRAYTYPE_P(0);
722 14 : int ndims = ARR_NDIM(in_array);
723 : int count;
724 : int32 buflen;
725 : HStore *out;
726 : Pairs *pairs;
727 : Datum *in_datums;
728 : bool *in_nulls;
729 : int in_count;
730 : int i;
731 :
732 : Assert(ARR_ELEMTYPE(in_array) == TEXTOID);
733 :
734 14 : switch (ndims)
735 : {
736 2 : case 0:
737 2 : out = hstorePairs(NULL, 0, 0);
738 2 : PG_RETURN_POINTER(out);
739 :
740 5 : case 1:
741 5 : if ((ARR_DIMS(in_array)[0]) % 2)
742 2 : ereport(ERROR,
743 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
744 : errmsg("array must have even number of elements")));
745 3 : break;
746 :
747 5 : case 2:
748 5 : if ((ARR_DIMS(in_array)[1]) != 2)
749 2 : ereport(ERROR,
750 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
751 : errmsg("array must have two columns")));
752 3 : break;
753 :
754 2 : default:
755 2 : ereport(ERROR,
756 : (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
757 : errmsg("wrong number of array subscripts")));
758 : }
759 :
760 6 : deconstruct_array_builtin(in_array, TEXTOID, &in_datums, &in_nulls, &in_count);
761 :
762 6 : count = in_count / 2;
763 :
764 : /* see discussion in hstoreArrayToPairs() */
765 6 : if (count > MaxAllocSize / sizeof(Pairs))
766 0 : ereport(ERROR,
767 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
768 : errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
769 : count, (int) (MaxAllocSize / sizeof(Pairs)))));
770 :
771 6 : pairs = palloc(count * sizeof(Pairs));
772 :
773 24 : for (i = 0; i < count; ++i)
774 : {
775 18 : if (in_nulls[i * 2])
776 0 : ereport(ERROR,
777 : (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
778 : errmsg("null value not allowed for hstore key")));
779 :
780 18 : if (in_nulls[i * 2 + 1])
781 : {
782 0 : pairs[i].key = VARDATA(DatumGetPointer(in_datums[i * 2]));
783 0 : pairs[i].val = NULL;
784 0 : pairs[i].keylen =
785 0 : hstoreCheckKeyLen(VARSIZE(DatumGetPointer(in_datums[i * 2])) - VARHDRSZ);
786 0 : pairs[i].vallen = 4;
787 0 : pairs[i].isnull = true;
788 0 : pairs[i].needfree = false;
789 : }
790 : else
791 : {
792 18 : pairs[i].key = VARDATA(DatumGetPointer(in_datums[i * 2]));
793 18 : pairs[i].val = VARDATA(DatumGetPointer(in_datums[i * 2 + 1]));
794 36 : pairs[i].keylen =
795 18 : hstoreCheckKeyLen(VARSIZE(DatumGetPointer(in_datums[i * 2])) - VARHDRSZ);
796 36 : pairs[i].vallen =
797 18 : hstoreCheckValLen(VARSIZE(DatumGetPointer(in_datums[i * 2 + 1])) - VARHDRSZ);
798 18 : pairs[i].isnull = false;
799 18 : pairs[i].needfree = false;
800 : }
801 : }
802 :
803 6 : count = hstoreUniquePairs(pairs, count, &buflen);
804 :
805 6 : out = hstorePairs(pairs, count, buflen);
806 :
807 6 : PG_RETURN_POINTER(out);
808 : }
809 :
810 : /* most of hstore_from_record is shamelessly swiped from record_out */
811 :
812 : /*
813 : * structure to cache metadata needed for record I/O
814 : */
815 : typedef struct ColumnIOData
816 : {
817 : Oid column_type;
818 : Oid typiofunc;
819 : Oid typioparam;
820 : FmgrInfo proc;
821 : } ColumnIOData;
822 :
823 : typedef struct RecordIOData
824 : {
825 : Oid record_type;
826 : int32 record_typmod;
827 : /* this field is used only if target type is domain over composite: */
828 : void *domain_info; /* opaque cache for domain checks */
829 : int ncolumns;
830 : ColumnIOData columns[FLEXIBLE_ARRAY_MEMBER];
831 : } RecordIOData;
832 :
833 8 : PG_FUNCTION_INFO_V1(hstore_from_record);
834 : Datum
835 5 : hstore_from_record(PG_FUNCTION_ARGS)
836 : {
837 : HeapTupleHeader rec;
838 : int32 buflen;
839 : HStore *out;
840 : Pairs *pairs;
841 : Oid tupType;
842 : int32 tupTypmod;
843 : TupleDesc tupdesc;
844 : HeapTupleData tuple;
845 : RecordIOData *my_extra;
846 : int ncolumns;
847 : int i,
848 : j;
849 : Datum *values;
850 : bool *nulls;
851 :
852 5 : if (PG_ARGISNULL(0))
853 : {
854 2 : Oid argtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
855 :
856 : /*
857 : * We have no tuple to look at, so the only source of type info is the
858 : * argtype --- which might be domain over composite, but we don't care
859 : * here, since we have no need to be concerned about domain
860 : * constraints. The lookup_rowtype_tupdesc_domain call below will
861 : * error out if we don't have a known composite type oid here.
862 : */
863 2 : tupType = argtype;
864 2 : tupTypmod = -1;
865 :
866 2 : rec = NULL;
867 : }
868 : else
869 : {
870 3 : rec = PG_GETARG_HEAPTUPLEHEADER(0);
871 :
872 : /*
873 : * Extract type info from the tuple itself -- this will work even for
874 : * anonymous record types.
875 : */
876 3 : tupType = HeapTupleHeaderGetTypeId(rec);
877 3 : tupTypmod = HeapTupleHeaderGetTypMod(rec);
878 : }
879 :
880 5 : tupdesc = lookup_rowtype_tupdesc_domain(tupType, tupTypmod, false);
881 5 : ncolumns = tupdesc->natts;
882 :
883 : /*
884 : * We arrange to look up the needed I/O info just once per series of
885 : * calls, assuming the record type doesn't change underneath us.
886 : */
887 5 : my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
888 5 : if (my_extra == NULL ||
889 0 : my_extra->ncolumns != ncolumns)
890 : {
891 10 : fcinfo->flinfo->fn_extra =
892 5 : MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
893 : offsetof(RecordIOData, columns) +
894 5 : ncolumns * sizeof(ColumnIOData));
895 5 : my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
896 5 : my_extra->record_type = InvalidOid;
897 5 : my_extra->record_typmod = 0;
898 : }
899 :
900 5 : if (my_extra->record_type != tupType ||
901 0 : my_extra->record_typmod != tupTypmod)
902 : {
903 204 : MemSet(my_extra, 0,
904 : offsetof(RecordIOData, columns) +
905 : ncolumns * sizeof(ColumnIOData));
906 5 : my_extra->record_type = tupType;
907 5 : my_extra->record_typmod = tupTypmod;
908 5 : my_extra->ncolumns = ncolumns;
909 : }
910 :
911 : Assert(ncolumns <= MaxTupleAttributeNumber); /* thus, no overflow */
912 5 : pairs = palloc(ncolumns * sizeof(Pairs));
913 :
914 5 : if (rec)
915 : {
916 : /* Build a temporary HeapTuple control structure */
917 3 : tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
918 3 : ItemPointerSetInvalid(&(tuple.t_self));
919 3 : tuple.t_tableOid = InvalidOid;
920 3 : tuple.t_data = rec;
921 :
922 3 : values = (Datum *) palloc(ncolumns * sizeof(Datum));
923 3 : nulls = (bool *) palloc(ncolumns * sizeof(bool));
924 :
925 : /* Break down the tuple into fields */
926 3 : heap_deform_tuple(&tuple, tupdesc, values, nulls);
927 : }
928 : else
929 : {
930 2 : values = NULL;
931 2 : nulls = NULL;
932 : }
933 :
934 28 : for (i = 0, j = 0; i < ncolumns; ++i)
935 : {
936 23 : ColumnIOData *column_info = &my_extra->columns[i];
937 23 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
938 23 : Oid column_type = att->atttypid;
939 : char *value;
940 :
941 : /* Ignore dropped columns in datatype */
942 23 : if (att->attisdropped)
943 0 : continue;
944 :
945 23 : pairs[j].key = NameStr(att->attname);
946 23 : pairs[j].keylen = hstoreCheckKeyLen(strlen(NameStr(att->attname)));
947 :
948 23 : if (!nulls || nulls[i])
949 : {
950 9 : pairs[j].val = NULL;
951 9 : pairs[j].vallen = 4;
952 9 : pairs[j].isnull = true;
953 9 : pairs[j].needfree = false;
954 9 : ++j;
955 9 : continue;
956 : }
957 :
958 : /*
959 : * Convert the column value to text
960 : */
961 14 : if (column_info->column_type != column_type)
962 : {
963 : bool typIsVarlena;
964 :
965 14 : getTypeOutputInfo(column_type,
966 : &column_info->typiofunc,
967 : &typIsVarlena);
968 14 : fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
969 14 : fcinfo->flinfo->fn_mcxt);
970 14 : column_info->column_type = column_type;
971 : }
972 :
973 14 : value = OutputFunctionCall(&column_info->proc, values[i]);
974 :
975 14 : pairs[j].val = value;
976 14 : pairs[j].vallen = hstoreCheckValLen(strlen(value));
977 14 : pairs[j].isnull = false;
978 14 : pairs[j].needfree = false;
979 14 : ++j;
980 : }
981 :
982 5 : ncolumns = hstoreUniquePairs(pairs, j, &buflen);
983 :
984 5 : out = hstorePairs(pairs, ncolumns, buflen);
985 :
986 5 : ReleaseTupleDesc(tupdesc);
987 :
988 5 : PG_RETURN_POINTER(out);
989 : }
990 :
991 :
992 8 : PG_FUNCTION_INFO_V1(hstore_populate_record);
993 : Datum
994 33 : hstore_populate_record(PG_FUNCTION_ARGS)
995 : {
996 33 : Oid argtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
997 : HStore *hs;
998 : HEntry *entries;
999 : char *ptr;
1000 : HeapTupleHeader rec;
1001 : Oid tupType;
1002 : int32 tupTypmod;
1003 : TupleDesc tupdesc;
1004 : HeapTupleData tuple;
1005 : HeapTuple rettuple;
1006 : RecordIOData *my_extra;
1007 : int ncolumns;
1008 : int i;
1009 : Datum *values;
1010 : bool *nulls;
1011 :
1012 33 : if (!type_is_rowtype(argtype))
1013 0 : ereport(ERROR,
1014 : (errcode(ERRCODE_DATATYPE_MISMATCH),
1015 : errmsg("first argument must be a rowtype")));
1016 :
1017 33 : if (PG_ARGISNULL(0))
1018 : {
1019 8 : if (PG_ARGISNULL(1))
1020 0 : PG_RETURN_NULL();
1021 :
1022 8 : rec = NULL;
1023 :
1024 : /*
1025 : * We have no tuple to look at, so the only source of type info is the
1026 : * argtype. The lookup_rowtype_tupdesc_domain call below will error
1027 : * out if we don't have a known composite type oid here.
1028 : */
1029 8 : tupType = argtype;
1030 8 : tupTypmod = -1;
1031 : }
1032 : else
1033 : {
1034 25 : rec = PG_GETARG_HEAPTUPLEHEADER(0);
1035 :
1036 25 : if (PG_ARGISNULL(1))
1037 0 : PG_RETURN_POINTER(rec);
1038 :
1039 : /*
1040 : * Extract type info from the tuple itself -- this will work even for
1041 : * anonymous record types.
1042 : */
1043 25 : tupType = HeapTupleHeaderGetTypeId(rec);
1044 25 : tupTypmod = HeapTupleHeaderGetTypMod(rec);
1045 : }
1046 :
1047 33 : hs = PG_GETARG_HSTORE_P(1);
1048 33 : entries = ARRPTR(hs);
1049 33 : ptr = STRPTR(hs);
1050 :
1051 : /*
1052 : * if the input hstore is empty, we can only skip the rest if we were
1053 : * passed in a non-null record, since otherwise there may be issues with
1054 : * domain nulls.
1055 : */
1056 :
1057 33 : if (HS_COUNT(hs) == 0 && rec)
1058 4 : PG_RETURN_POINTER(rec);
1059 :
1060 : /*
1061 : * Lookup the input record's tupdesc. For the moment, we don't worry
1062 : * about whether it is a domain over composite.
1063 : */
1064 29 : tupdesc = lookup_rowtype_tupdesc_domain(tupType, tupTypmod, false);
1065 29 : ncolumns = tupdesc->natts;
1066 :
1067 29 : if (rec)
1068 : {
1069 : /* Build a temporary HeapTuple control structure */
1070 21 : tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
1071 21 : ItemPointerSetInvalid(&(tuple.t_self));
1072 21 : tuple.t_tableOid = InvalidOid;
1073 21 : tuple.t_data = rec;
1074 : }
1075 :
1076 : /*
1077 : * We arrange to look up the needed I/O info just once per series of
1078 : * calls, assuming the record type doesn't change underneath us.
1079 : */
1080 29 : my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
1081 29 : if (my_extra == NULL ||
1082 4 : my_extra->ncolumns != ncolumns)
1083 : {
1084 50 : fcinfo->flinfo->fn_extra =
1085 25 : MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
1086 : offsetof(RecordIOData, columns) +
1087 25 : ncolumns * sizeof(ColumnIOData));
1088 25 : my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
1089 25 : my_extra->record_type = InvalidOid;
1090 25 : my_extra->record_typmod = 0;
1091 25 : my_extra->domain_info = NULL;
1092 : }
1093 :
1094 29 : if (my_extra->record_type != tupType ||
1095 4 : my_extra->record_typmod != tupTypmod)
1096 : {
1097 1068 : MemSet(my_extra, 0,
1098 : offsetof(RecordIOData, columns) +
1099 : ncolumns * sizeof(ColumnIOData));
1100 25 : my_extra->record_type = tupType;
1101 25 : my_extra->record_typmod = tupTypmod;
1102 25 : my_extra->ncolumns = ncolumns;
1103 : }
1104 :
1105 29 : values = (Datum *) palloc(ncolumns * sizeof(Datum));
1106 29 : nulls = (bool *) palloc(ncolumns * sizeof(bool));
1107 :
1108 29 : if (rec)
1109 : {
1110 : /* Break down the tuple into fields */
1111 21 : heap_deform_tuple(&tuple, tupdesc, values, nulls);
1112 : }
1113 : else
1114 : {
1115 46 : for (i = 0; i < ncolumns; ++i)
1116 : {
1117 38 : values[i] = (Datum) 0;
1118 38 : nulls[i] = true;
1119 : }
1120 : }
1121 :
1122 163 : for (i = 0; i < ncolumns; ++i)
1123 : {
1124 141 : ColumnIOData *column_info = &my_extra->columns[i];
1125 141 : Form_pg_attribute att = TupleDescAttr(tupdesc, i);
1126 141 : Oid column_type = att->atttypid;
1127 : char *value;
1128 : int idx;
1129 : int vallen;
1130 :
1131 : /* Ignore dropped columns in datatype */
1132 141 : if (att->attisdropped)
1133 : {
1134 0 : nulls[i] = true;
1135 0 : continue;
1136 : }
1137 :
1138 141 : idx = hstoreFindKey(hs, 0,
1139 141 : NameStr(att->attname),
1140 141 : strlen(NameStr(att->attname)));
1141 :
1142 : /*
1143 : * we can't just skip here if the key wasn't found since we might have
1144 : * a domain to deal with. If we were passed in a non-null record
1145 : * datum, we assume that the existing values are valid (if they're
1146 : * not, then it's not our fault), but if we were passed in a null,
1147 : * then every field which we don't populate needs to be run through
1148 : * the input function just in case it's a domain type.
1149 : */
1150 141 : if (idx < 0 && rec)
1151 79 : continue;
1152 :
1153 : /*
1154 : * Prepare to convert the column value from text
1155 : */
1156 62 : if (column_info->column_type != column_type)
1157 : {
1158 61 : getTypeInputInfo(column_type,
1159 : &column_info->typiofunc,
1160 : &column_info->typioparam);
1161 61 : fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
1162 61 : fcinfo->flinfo->fn_mcxt);
1163 61 : column_info->column_type = column_type;
1164 : }
1165 :
1166 62 : if (idx < 0 || HSTORE_VALISNULL(entries, idx))
1167 : {
1168 : /*
1169 : * need InputFunctionCall to happen even for nulls, so that domain
1170 : * checks are done
1171 : */
1172 36 : values[i] = InputFunctionCall(&column_info->proc, NULL,
1173 : column_info->typioparam,
1174 : att->atttypmod);
1175 29 : nulls[i] = true;
1176 : }
1177 : else
1178 : {
1179 26 : vallen = HSTORE_VALLEN(entries, idx);
1180 26 : value = palloc(1 + vallen);
1181 26 : memcpy(value, HSTORE_VAL(entries, ptr, idx), vallen);
1182 26 : value[vallen] = 0;
1183 :
1184 26 : values[i] = InputFunctionCall(&column_info->proc, value,
1185 : column_info->typioparam,
1186 : att->atttypmod);
1187 26 : nulls[i] = false;
1188 : }
1189 : }
1190 :
1191 22 : rettuple = heap_form_tuple(tupdesc, values, nulls);
1192 :
1193 : /*
1194 : * If the target type is domain over composite, all we know at this point
1195 : * is that we've made a valid value of the base composite type. Must
1196 : * check domain constraints before deciding we're done.
1197 : */
1198 22 : if (argtype != tupdesc->tdtypeid)
1199 0 : domain_check(HeapTupleGetDatum(rettuple), false,
1200 : argtype,
1201 : &my_extra->domain_info,
1202 0 : fcinfo->flinfo->fn_mcxt);
1203 :
1204 22 : ReleaseTupleDesc(tupdesc);
1205 :
1206 22 : PG_RETURN_DATUM(HeapTupleGetDatum(rettuple));
1207 : }
1208 :
1209 :
1210 : static char *
1211 505 : cpw(char *dst, char *src, int len)
1212 : {
1213 505 : char *ptr = src;
1214 :
1215 1464 : while (ptr - src < len)
1216 : {
1217 959 : if (*ptr == '"' || *ptr == '\\')
1218 3 : *dst++ = '\\';
1219 959 : *dst++ = *ptr++;
1220 : }
1221 505 : return dst;
1222 : }
1223 :
1224 17 : PG_FUNCTION_INFO_V1(hstore_out);
1225 : Datum
1226 147 : hstore_out(PG_FUNCTION_ARGS)
1227 : {
1228 147 : HStore *in = PG_GETARG_HSTORE_P(0);
1229 : int buflen,
1230 : i;
1231 147 : int count = HS_COUNT(in);
1232 : char *out,
1233 : *ptr;
1234 147 : char *base = STRPTR(in);
1235 147 : HEntry *entries = ARRPTR(in);
1236 :
1237 147 : if (count == 0)
1238 13 : PG_RETURN_CSTRING(pstrdup(""));
1239 :
1240 134 : buflen = 0;
1241 :
1242 : /*
1243 : * this loop overestimates due to pessimistic assumptions about escaping,
1244 : * so very large hstore values can't be output. this could be fixed, but
1245 : * many other data types probably have the same issue. This replaced code
1246 : * that used the original varlena size for calculations, which was wrong
1247 : * in some subtle ways.
1248 : */
1249 :
1250 404 : for (i = 0; i < count; i++)
1251 : {
1252 : /* include "" and => and comma-space */
1253 270 : buflen += 6 + 2 * HSTORE_KEYLEN(entries, i);
1254 : /* include "" only if nonnull */
1255 505 : buflen += 2 + (HSTORE_VALISNULL(entries, i)
1256 : ? 2
1257 235 : : 2 * HSTORE_VALLEN(entries, i));
1258 : }
1259 :
1260 134 : out = ptr = palloc(buflen);
1261 :
1262 404 : for (i = 0; i < count; i++)
1263 : {
1264 270 : *ptr++ = '"';
1265 270 : ptr = cpw(ptr, HSTORE_KEY(entries, base, i), HSTORE_KEYLEN(entries, i));
1266 270 : *ptr++ = '"';
1267 270 : *ptr++ = '=';
1268 270 : *ptr++ = '>';
1269 270 : if (HSTORE_VALISNULL(entries, i))
1270 : {
1271 35 : *ptr++ = 'N';
1272 35 : *ptr++ = 'U';
1273 35 : *ptr++ = 'L';
1274 35 : *ptr++ = 'L';
1275 : }
1276 : else
1277 : {
1278 235 : *ptr++ = '"';
1279 235 : ptr = cpw(ptr, HSTORE_VAL(entries, base, i), HSTORE_VALLEN(entries, i));
1280 235 : *ptr++ = '"';
1281 : }
1282 :
1283 270 : if (i + 1 != count)
1284 : {
1285 136 : *ptr++ = ',';
1286 136 : *ptr++ = ' ';
1287 : }
1288 : }
1289 134 : *ptr = '\0';
1290 :
1291 134 : PG_RETURN_CSTRING(out);
1292 : }
1293 :
1294 :
1295 7 : PG_FUNCTION_INFO_V1(hstore_send);
1296 : Datum
1297 0 : hstore_send(PG_FUNCTION_ARGS)
1298 : {
1299 0 : HStore *in = PG_GETARG_HSTORE_P(0);
1300 : int i;
1301 0 : int count = HS_COUNT(in);
1302 0 : char *base = STRPTR(in);
1303 0 : HEntry *entries = ARRPTR(in);
1304 : StringInfoData buf;
1305 :
1306 0 : pq_begintypsend(&buf);
1307 :
1308 0 : pq_sendint32(&buf, count);
1309 :
1310 0 : for (i = 0; i < count; i++)
1311 : {
1312 0 : int32 keylen = HSTORE_KEYLEN(entries, i);
1313 :
1314 0 : pq_sendint32(&buf, keylen);
1315 0 : pq_sendtext(&buf, HSTORE_KEY(entries, base, i), keylen);
1316 0 : if (HSTORE_VALISNULL(entries, i))
1317 : {
1318 0 : pq_sendint32(&buf, -1);
1319 : }
1320 : else
1321 : {
1322 0 : int32 vallen = HSTORE_VALLEN(entries, i);
1323 :
1324 0 : pq_sendint32(&buf, vallen);
1325 0 : pq_sendtext(&buf, HSTORE_VAL(entries, base, i), vallen);
1326 : }
1327 : }
1328 :
1329 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
1330 : }
1331 :
1332 :
1333 : /*
1334 : * hstore_to_json_loose
1335 : *
1336 : * This is a heuristic conversion to json which treats
1337 : * 't' and 'f' as booleans and strings that look like numbers as numbers,
1338 : * as long as they don't start with a leading zero followed by another digit
1339 : * (think zip codes or phone numbers starting with 0).
1340 : */
1341 8 : PG_FUNCTION_INFO_V1(hstore_to_json_loose);
1342 : Datum
1343 3 : hstore_to_json_loose(PG_FUNCTION_ARGS)
1344 : {
1345 3 : HStore *in = PG_GETARG_HSTORE_P(0);
1346 : int i;
1347 3 : int count = HS_COUNT(in);
1348 3 : char *base = STRPTR(in);
1349 3 : HEntry *entries = ARRPTR(in);
1350 : StringInfoData dst;
1351 :
1352 3 : if (count == 0)
1353 0 : PG_RETURN_TEXT_P(cstring_to_text_with_len("{}", 2));
1354 :
1355 3 : initStringInfo(&dst);
1356 :
1357 3 : appendStringInfoChar(&dst, '{');
1358 :
1359 25 : for (i = 0; i < count; i++)
1360 : {
1361 66 : escape_json_with_len(&dst,
1362 22 : HSTORE_KEY(entries, base, i),
1363 22 : HSTORE_KEYLEN(entries, i));
1364 22 : appendStringInfoString(&dst, ": ");
1365 22 : if (HSTORE_VALISNULL(entries, i))
1366 2 : appendStringInfoString(&dst, "null");
1367 : /* guess that values of 't' or 'f' are booleans */
1368 20 : else if (HSTORE_VALLEN(entries, i) == 1 &&
1369 6 : *(HSTORE_VAL(entries, base, i)) == 't')
1370 2 : appendStringInfoString(&dst, "true");
1371 18 : else if (HSTORE_VALLEN(entries, i) == 1 &&
1372 4 : *(HSTORE_VAL(entries, base, i)) == 'f')
1373 1 : appendStringInfoString(&dst, "false");
1374 : else
1375 : {
1376 17 : char *str = HSTORE_VAL(entries, base, i);
1377 17 : int len = HSTORE_VALLEN(entries, i);
1378 :
1379 17 : if (IsValidJsonNumber(str, len))
1380 12 : appendBinaryStringInfo(&dst, str, len);
1381 : else
1382 5 : escape_json_with_len(&dst, str, len);
1383 : }
1384 :
1385 22 : if (i + 1 != count)
1386 19 : appendStringInfoString(&dst, ", ");
1387 : }
1388 3 : appendStringInfoChar(&dst, '}');
1389 :
1390 3 : PG_RETURN_TEXT_P(cstring_to_text_with_len(dst.data, dst.len));
1391 : }
1392 :
1393 8 : PG_FUNCTION_INFO_V1(hstore_to_json);
1394 : Datum
1395 4 : hstore_to_json(PG_FUNCTION_ARGS)
1396 : {
1397 4 : HStore *in = PG_GETARG_HSTORE_P(0);
1398 : int i;
1399 4 : int count = HS_COUNT(in);
1400 4 : char *base = STRPTR(in);
1401 4 : HEntry *entries = ARRPTR(in);
1402 : StringInfoData dst;
1403 :
1404 4 : if (count == 0)
1405 0 : PG_RETURN_TEXT_P(cstring_to_text_with_len("{}", 2));
1406 :
1407 4 : initStringInfo(&dst);
1408 :
1409 4 : appendStringInfoChar(&dst, '{');
1410 :
1411 32 : for (i = 0; i < count; i++)
1412 : {
1413 84 : escape_json_with_len(&dst,
1414 28 : HSTORE_KEY(entries, base, i),
1415 28 : HSTORE_KEYLEN(entries, i));
1416 28 : appendStringInfoString(&dst, ": ");
1417 28 : if (HSTORE_VALISNULL(entries, i))
1418 3 : appendStringInfoString(&dst, "null");
1419 : else
1420 : {
1421 75 : escape_json_with_len(&dst,
1422 25 : HSTORE_VAL(entries, base, i),
1423 25 : HSTORE_VALLEN(entries, i));
1424 : }
1425 :
1426 28 : if (i + 1 != count)
1427 24 : appendStringInfoString(&dst, ", ");
1428 : }
1429 4 : appendStringInfoChar(&dst, '}');
1430 :
1431 4 : PG_RETURN_TEXT_P(cstring_to_text_with_len(dst.data, dst.len));
1432 : }
1433 :
1434 8 : PG_FUNCTION_INFO_V1(hstore_to_jsonb);
1435 : Datum
1436 2 : hstore_to_jsonb(PG_FUNCTION_ARGS)
1437 : {
1438 2 : HStore *in = PG_GETARG_HSTORE_P(0);
1439 : int i;
1440 2 : int count = HS_COUNT(in);
1441 2 : char *base = STRPTR(in);
1442 2 : HEntry *entries = ARRPTR(in);
1443 2 : JsonbInState state = {0};
1444 :
1445 2 : pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL);
1446 :
1447 16 : for (i = 0; i < count; i++)
1448 : {
1449 : JsonbValue key,
1450 : val;
1451 :
1452 14 : key.type = jbvString;
1453 14 : key.val.string.len = HSTORE_KEYLEN(entries, i);
1454 14 : key.val.string.val = HSTORE_KEY(entries, base, i);
1455 :
1456 14 : pushJsonbValue(&state, WJB_KEY, &key);
1457 :
1458 14 : if (HSTORE_VALISNULL(entries, i))
1459 : {
1460 2 : val.type = jbvNull;
1461 : }
1462 : else
1463 : {
1464 12 : val.type = jbvString;
1465 12 : val.val.string.len = HSTORE_VALLEN(entries, i);
1466 12 : val.val.string.val = HSTORE_VAL(entries, base, i);
1467 : }
1468 14 : pushJsonbValue(&state, WJB_VALUE, &val);
1469 : }
1470 :
1471 2 : pushJsonbValue(&state, WJB_END_OBJECT, NULL);
1472 :
1473 2 : PG_RETURN_POINTER(JsonbValueToJsonb(state.result));
1474 : }
1475 :
1476 8 : PG_FUNCTION_INFO_V1(hstore_to_jsonb_loose);
1477 : Datum
1478 1 : hstore_to_jsonb_loose(PG_FUNCTION_ARGS)
1479 : {
1480 1 : HStore *in = PG_GETARG_HSTORE_P(0);
1481 : int i;
1482 1 : int count = HS_COUNT(in);
1483 1 : char *base = STRPTR(in);
1484 1 : HEntry *entries = ARRPTR(in);
1485 1 : JsonbInState state = {0};
1486 : StringInfoData tmp;
1487 :
1488 1 : initStringInfo(&tmp);
1489 :
1490 1 : pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL);
1491 :
1492 9 : for (i = 0; i < count; i++)
1493 : {
1494 : JsonbValue key,
1495 : val;
1496 :
1497 8 : key.type = jbvString;
1498 8 : key.val.string.len = HSTORE_KEYLEN(entries, i);
1499 8 : key.val.string.val = HSTORE_KEY(entries, base, i);
1500 :
1501 8 : pushJsonbValue(&state, WJB_KEY, &key);
1502 :
1503 8 : if (HSTORE_VALISNULL(entries, i))
1504 : {
1505 1 : val.type = jbvNull;
1506 : }
1507 : /* guess that values of 't' or 'f' are booleans */
1508 7 : else if (HSTORE_VALLEN(entries, i) == 1 &&
1509 2 : *(HSTORE_VAL(entries, base, i)) == 't')
1510 : {
1511 1 : val.type = jbvBool;
1512 1 : val.val.boolean = true;
1513 : }
1514 6 : else if (HSTORE_VALLEN(entries, i) == 1 &&
1515 1 : *(HSTORE_VAL(entries, base, i)) == 'f')
1516 : {
1517 0 : val.type = jbvBool;
1518 0 : val.val.boolean = false;
1519 : }
1520 : else
1521 : {
1522 6 : resetStringInfo(&tmp);
1523 6 : appendBinaryStringInfo(&tmp, HSTORE_VAL(entries, base, i),
1524 6 : HSTORE_VALLEN(entries, i));
1525 6 : if (IsValidJsonNumber(tmp.data, tmp.len))
1526 : {
1527 : Datum numd;
1528 :
1529 4 : val.type = jbvNumeric;
1530 4 : numd = DirectFunctionCall3(numeric_in,
1531 : CStringGetDatum(tmp.data),
1532 : ObjectIdGetDatum(InvalidOid),
1533 : Int32GetDatum(-1));
1534 4 : val.val.numeric = DatumGetNumeric(numd);
1535 : }
1536 : else
1537 : {
1538 2 : val.type = jbvString;
1539 2 : val.val.string.len = HSTORE_VALLEN(entries, i);
1540 2 : val.val.string.val = HSTORE_VAL(entries, base, i);
1541 : }
1542 : }
1543 8 : pushJsonbValue(&state, WJB_VALUE, &val);
1544 : }
1545 :
1546 1 : pushJsonbValue(&state, WJB_END_OBJECT, NULL);
1547 :
1548 1 : PG_RETURN_POINTER(JsonbValueToJsonb(state.result));
1549 : }
|
