nested hstore
[hstore.git] / hstore_io.c
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 "catalog/pg_cast.h"
11 #include "funcapi.h"
12 #include "libpq/pqformat.h"
13 #include "miscadmin.h"
14 #include "parser/parse_coerce.h"
15 #include "utils/builtins.h"
16 #include "utils/fmgroids.h"
17 #include "utils/json.h"
18 #include "utils/guc.h"
19 #include "utils/lsyscache.h"
20 #include "utils/memutils.h"
21 #include "utils/syscache.h"
22 #include "utils/typcache.h"
23
24 #include "hstore.h"
25
26 PG_MODULE_MAGIC;
27
28 /* old names for C functions */
29 HSTORE_POLLUTE(hstore_from_text, tconvert);
30
31 /* GUC variables */
32 static bool     pretty_print_var = false;
33 #define SET_PRETTY_PRINT_VAR(x)         ((pretty_print_var) ? \
34                                                                          ((x) | PrettyPrint) : (x))
35
36 static void recvHStore(StringInfo buf, HStoreValue *v, uint32 level,
37                                            uint32 header);
38 static Oid searchCast(Oid src, Oid dst, CoercionMethod *method);
39
40 static size_t
41 hstoreCheckKeyLen(size_t len)
42 {
43         if (len > HSTORE_MAX_KEY_LEN)
44                 ereport(ERROR,
45                                 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
46                                  errmsg("string too long for hstore key")));
47         return len;
48 }
49
50 static size_t
51 hstoreCheckValLen(size_t len)
52 {
53         if (len > HSTORE_MAX_VALUE_LEN)
54                 ereport(ERROR,
55                                 (errcode(ERRCODE_STRING_DATA_RIGHT_TRUNCATION),
56                                  errmsg("string too long for hstore value")));
57         return len;
58 }
59
60
61 static HStore*
62 hstoreDump(HStoreValue *p)
63 {
64         uint32                  buflen;
65         HStore             *out;
66
67         if (p == NULL || (p->type == hsvArray && p->array.nelems == 0) ||
68                 (p->type == hsvHash && p->hash.npairs == 0))
69         {
70                 buflen = 0;
71                 out = palloc(VARHDRSZ);
72         }
73         else
74         {
75                 buflen = VARHDRSZ + p->size;
76                 out = palloc(buflen);
77                 SET_VARSIZE(out, buflen);
78
79                 buflen = compressHStore(p, VARDATA(out));
80         }
81         SET_VARSIZE(out, buflen + VARHDRSZ);
82
83         return out;
84 }
85
86 PG_FUNCTION_INFO_V1(hstore_in);
87 Datum           hstore_in(PG_FUNCTION_ARGS);
88 Datum
89 hstore_in(PG_FUNCTION_ARGS)
90 {
91         PG_RETURN_POINTER(hstoreDump(parseHStore(PG_GETARG_CSTRING(0), -1, false)));
92 }
93
94 static void
95 recvHStoreValue(StringInfo buf, HStoreValue *v, uint32 level, int c)
96 {
97         uint32  hentry = c & HENTRY_TYPEMASK;
98
99         check_stack_depth();
100
101         if (c == -1 /* compatibility */ || hentry == HENTRY_ISNULL)
102         {
103                 v->type = hsvNull;
104                 v->size = sizeof(HEntry);
105         }
106         else if (hentry == HENTRY_ISHASH || hentry == HENTRY_ISARRAY ||
107                          hentry == HENTRY_ISSCALAR)
108         {
109                 recvHStore(buf, v, level + 1, (uint32)c);
110         }
111         else if (hentry == HENTRY_ISFALSE || hentry == HENTRY_ISTRUE)
112         {
113                 v->type = hsvBool;
114                 v->size = sizeof(HEntry);
115                 v->boolean = (hentry == HENTRY_ISFALSE) ? false : true;
116         }
117         else if (hentry == HENTRY_ISNUMERIC)
118         {
119                 v->type = hsvNumeric;
120                 v->numeric = DatumGetNumeric(DirectFunctionCall3(numeric_recv,
121                                                                                                                  PointerGetDatum(buf),
122                                                                                                                  Int32GetDatum(0),
123                                                                                                                  Int32GetDatum(-1)));
124                 v->size = sizeof(HEntry) * 2 + VARSIZE_ANY(v->numeric);
125         }
126         else if (hentry == HENTRY_ISSTRING)
127         {
128                 v->type = hsvString;
129                 v->string.val = pq_getmsgtext(buf, c & ~HENTRY_TYPEMASK, &c);
130                 v->string.len = hstoreCheckKeyLen(c);
131                 v->size = sizeof(HEntry) + v->string.len;
132         }
133         else
134         {
135                 ereport(ERROR,
136                                 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
137                                  errmsg("unknown hstore value")));
138         }
139 }
140
141 static void
142 recvHStore(StringInfo buf, HStoreValue *v, uint32 level, uint32 header)
143 {
144         uint32  hentry;
145         uint32  i;
146
147         hentry = header & HENTRY_TYPEMASK;
148
149         if (level == 0 && hentry == 0)
150                 hentry = HENTRY_ISHASH; /* old version */
151
152         check_stack_depth();
153
154         v->size = 3 * sizeof(HEntry);
155         if (hentry == HENTRY_ISHASH)
156         {
157                 v->type = hsvHash;
158                 v->hash.npairs = header & HS_COUNT_MASK;
159
160                 if (v->hash.npairs > (buf->len  - buf->cursor) / (2 * sizeof(uint32)) ||
161                         v->hash.npairs > MaxAllocSize / sizeof(HStorePair))
162                         ereport(ERROR,
163                                         (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
164                                          errmsg("too much elements in hstore hash")));
165
166                 if (v->hash.npairs > 0)
167                 {
168                         v->hash.pairs = palloc(sizeof(*v->hash.pairs) * v->hash.npairs);
169
170                         for(i=0; i<v->hash.npairs; i++)
171                         {
172                                 recvHStoreValue(buf, &v->hash.pairs[i].key, level,
173                                                                 pq_getmsgint(buf, 4));
174                                 if (v->hash.pairs[i].key.type != hsvString)
175                                         ereport(ERROR,
176                                                         (errcode(ERRCODE_DATATYPE_MISMATCH),
177                                                          errmsg("hstore's key could be only a string")));
178
179                                 recvHStoreValue(buf, &v->hash.pairs[i].value, level,
180                                                                 pq_getmsgint(buf, 4));
181
182                                 v->size += v->hash.pairs[i].key.size +
183                                                         v->hash.pairs[i].value.size;
184                         }
185
186                         uniqueHStoreValue(v);
187                 }
188         }
189         else if (hentry == HENTRY_ISARRAY || hentry == HENTRY_ISSCALAR)
190         {
191                 v->type = hsvArray;
192                 v->array.nelems = header & HS_COUNT_MASK;
193                 v->array.scalar = (hentry == HENTRY_ISSCALAR) ? true : false;
194
195                 if (v->array.nelems > (buf->len  - buf->cursor) / sizeof(uint32) ||
196                         v->array.nelems > MaxAllocSize / sizeof(HStoreValue))
197                         ereport(ERROR,
198                                         (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
199                                          errmsg("too much elements in hstore array")));
200
201                 if (v->array.scalar && v->array.nelems != 1)
202                         ereport(ERROR,
203                                         (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
204                                          errmsg("wrong scalar representation")));
205
206                 if (v->array.nelems > 0)
207                 {
208                         v->array.elems = palloc(sizeof(*v->array.elems) * v->array.nelems);
209
210                         for(i=0; i<v->array.nelems; i++)
211                         {
212                                 recvHStoreValue(buf, v->array.elems + i, level,
213                                                                 pq_getmsgint(buf, 4));
214                                 v->size += v->array.elems[i].size;
215                         }
216                 }
217         }
218         else
219         {
220                 ereport(ERROR,
221                                 (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
222                                  errmsg("unknown hstore element")));
223         }
224 }
225
226 PG_FUNCTION_INFO_V1(hstore_recv);
227 Datum           hstore_recv(PG_FUNCTION_ARGS);
228 Datum
229 hstore_recv(PG_FUNCTION_ARGS)
230 {
231         StringInfo      buf = (StringInfo) PG_GETARG_POINTER(0);
232         HStoreValue     v;
233
234         recvHStore(buf, &v, 0, pq_getmsgint(buf, 4));
235
236         PG_RETURN_POINTER(hstoreDump(&v));
237 }
238
239 PG_FUNCTION_INFO_V1(hstore_from_text);
240 Datum           hstore_from_text(PG_FUNCTION_ARGS);
241 Datum
242 hstore_from_text(PG_FUNCTION_ARGS)
243 {
244         text            *key;
245         HStoreValue     v;
246         HStorePair      pair;
247
248         if (PG_ARGISNULL(0))
249                 PG_RETURN_NULL();
250
251         key = PG_GETARG_TEXT_PP(0);
252         pair.key.type = hsvString;
253         pair.key.string.val = VARDATA_ANY(key);
254         pair.key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key));
255         pair.key.size = pair.key.string.len + sizeof(HEntry);
256
257         if (PG_ARGISNULL(1))
258         {
259                 pair.value.type = hsvNull;
260                 pair.value.size = sizeof(HEntry);
261         }
262         else
263         {
264                 text            *val = NULL;
265
266                 val = PG_GETARG_TEXT_PP(1);
267                 pair.value.type = hsvString;
268                 pair.value.string.val = VARDATA_ANY(val);
269                 pair.value.string.len = hstoreCheckValLen(VARSIZE_ANY_EXHDR(val));
270                 pair.value.size = pair.value.string.len + sizeof(HEntry);
271         }
272
273         v.type = hsvHash;
274         v.size = sizeof(HEntry) + pair.key.size + pair.value.size;
275         v.hash.npairs = 1;
276         v.hash.pairs = &pair;
277
278         PG_RETURN_POINTER(hstoreDump(&v));
279 }
280
281 PG_FUNCTION_INFO_V1(hstore_from_bool);
282 Datum           hstore_from_bool(PG_FUNCTION_ARGS);
283 Datum
284 hstore_from_bool(PG_FUNCTION_ARGS)
285 {
286         text            *key;
287         HStoreValue     v;
288         HStorePair      pair;
289
290         if (PG_ARGISNULL(0))
291                 PG_RETURN_NULL();
292
293         key = PG_GETARG_TEXT_PP(0);
294         pair.key.type = hsvString;
295         pair.key.string.val = VARDATA_ANY(key);
296         pair.key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key));
297         pair.key.size = pair.key.string.len + sizeof(HEntry);
298
299         if (PG_ARGISNULL(1))
300         {
301                 pair.value.type = hsvNull;
302                 pair.value.size = sizeof(HEntry);
303         }
304         else
305         {
306                 pair.value.type = hsvBool;
307                 pair.value.boolean = PG_GETARG_BOOL(1);
308                 pair.value.size = sizeof(HEntry);
309         }
310
311         v.type = hsvHash;
312         v.size = sizeof(HEntry) + pair.key.size + pair.value.size;
313         v.hash.npairs = 1;
314         v.hash.pairs = &pair;
315
316         PG_RETURN_POINTER(hstoreDump(&v));
317 }
318
319 PG_FUNCTION_INFO_V1(hstore_from_numeric);
320 Datum           hstore_from_numeric(PG_FUNCTION_ARGS);
321 Datum
322 hstore_from_numeric(PG_FUNCTION_ARGS)
323 {
324         text            *key;
325         HStoreValue     v;
326         HStorePair      pair;
327
328         if (PG_ARGISNULL(0))
329                 PG_RETURN_NULL();
330
331         key = PG_GETARG_TEXT_PP(0);
332         pair.key.type = hsvString;
333         pair.key.string.val = VARDATA_ANY(key);
334         pair.key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key));
335         pair.key.size = pair.key.string.len + sizeof(HEntry);
336
337         if (PG_ARGISNULL(1))
338         {
339                 pair.value.type = hsvNull;
340                 pair.value.size = sizeof(HEntry);
341         }
342         else
343         {
344                 pair.value.type = hsvNumeric;
345                 pair.value.numeric = PG_GETARG_NUMERIC(1);
346                 pair.value.size = sizeof(HEntry) + sizeof(HEntry) +
347                                                         VARSIZE_ANY(pair.value.numeric);
348         }
349
350         v.type = hsvHash;
351         v.size = sizeof(HEntry) + pair.key.size + pair.value.size;
352         v.hash.npairs = 1;
353         v.hash.pairs = &pair;
354
355         PG_RETURN_POINTER(hstoreDump(&v));
356 }
357
358 PG_FUNCTION_INFO_V1(hstore_from_th);
359 Datum           hstore_from_th(PG_FUNCTION_ARGS);
360 Datum
361 hstore_from_th(PG_FUNCTION_ARGS)
362 {
363         text            *key;
364         HStoreValue     v;
365         HStorePair      pair;
366
367         if (PG_ARGISNULL(0))
368                 PG_RETURN_NULL();
369
370         key = PG_GETARG_TEXT_PP(0);
371         pair.key.type = hsvString;
372         pair.key.string.val = VARDATA_ANY(key);
373         pair.key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key));
374         pair.key.size = pair.key.string.len + sizeof(HEntry);
375
376         if (PG_ARGISNULL(1))
377         {
378                 pair.value.type = hsvNull;
379                 pair.value.size = sizeof(HEntry);
380         }
381         else
382         {
383                 HStore          *val = NULL;
384
385                 val = PG_GETARG_HS(1);
386                 pair.value.type = hsvBinary;
387                 pair.value.binary.data = VARDATA_ANY(val);
388                 pair.value.binary.len = VARSIZE_ANY_EXHDR(val);
389                 pair.value.size = pair.value.binary.len + sizeof(HEntry) * 2;
390         }
391
392         v.type = hsvHash;
393         v.size = sizeof(HEntry) + pair.key.size + pair.value.size;
394         v.hash.npairs = 1;
395         v.hash.pairs = &pair;
396
397         PG_RETURN_POINTER(hstoreDump(&v));
398 }
399
400 PG_FUNCTION_INFO_V1(hstore_from_arrays);
401 PG_FUNCTION_INFO_V1(hstore_scalar_from_text);
402 Datum           hstore_scalar_from_text(PG_FUNCTION_ARGS);
403 Datum
404 hstore_scalar_from_text(PG_FUNCTION_ARGS)
405 {
406         HStoreValue     a, v;
407
408         if (PG_ARGISNULL(0))
409         {
410                 v.type = hsvNull;
411                 v.size = sizeof(HEntry);
412         }
413         else
414         {
415                 text    *scalar;
416
417                 scalar = PG_GETARG_TEXT_PP(0);
418                 v.type = hsvString;
419                 v.string.val = VARDATA_ANY(scalar);
420                 v.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(scalar));
421                 v.size = v.string.len + sizeof(HEntry);
422         }
423
424         a.type = hsvArray;
425         a.size = sizeof(HEntry) + v.size;
426         a.array.nelems = 1;
427         a.array.elems = &v;
428         a.array.scalar = true;
429
430         PG_RETURN_POINTER(hstoreDump(&a));
431 }
432
433 PG_FUNCTION_INFO_V1(hstore_scalar_from_bool);
434 Datum           hstore_scalar_from_bool(PG_FUNCTION_ARGS);
435 Datum
436 hstore_scalar_from_bool(PG_FUNCTION_ARGS)
437 {
438         HStoreValue     a, v;
439
440         if (PG_ARGISNULL(0))
441         {
442                 v.type = hsvNull;
443                 v.size = sizeof(HEntry);
444         }
445         else
446         {
447                 v.type = hsvBool;
448                 v.boolean = PG_GETARG_BOOL(0);
449                 v.size = sizeof(HEntry);
450         }
451
452         a.type = hsvArray;
453         a.size = sizeof(HEntry) + v.size;
454         a.array.nelems = 1;
455         a.array.elems = &v;
456         a.array.scalar = true;
457
458         PG_RETURN_POINTER(hstoreDump(&a));
459 }
460
461 PG_FUNCTION_INFO_V1(hstore_scalar_from_numeric);
462 Datum           hstore_scalar_from_numeric(PG_FUNCTION_ARGS);
463 Datum
464 hstore_scalar_from_numeric(PG_FUNCTION_ARGS)
465 {
466         HStoreValue     a, v;
467
468         if (PG_ARGISNULL(0))
469         {
470                 v.type = hsvNull;
471                 v.size = sizeof(HEntry);
472         }
473         else
474         {
475                 v.type = hsvNumeric;
476                 v.numeric = PG_GETARG_NUMERIC(0);
477                 v.size = VARSIZE_ANY(v.numeric) + 2*sizeof(HEntry);
478         }
479
480         a.type = hsvArray;
481         a.size = sizeof(HEntry) + v.size;
482         a.array.nelems = 1;
483         a.array.elems = &v;
484         a.array.scalar = true;
485
486         PG_RETURN_POINTER(hstoreDump(&a));
487 }
488
489 Datum           hstore_from_arrays(PG_FUNCTION_ARGS);
490 Datum
491 hstore_from_arrays(PG_FUNCTION_ARGS)
492 {
493         HStoreValue v;
494         Datum      *key_datums;
495         bool       *key_nulls;
496         int                     key_count;
497         Datum      *value_datums;
498         bool       *value_nulls;
499         int                     value_count;
500         ArrayType  *key_array;
501         ArrayType  *value_array;
502         int                     i;
503
504         if (PG_ARGISNULL(0))
505                 PG_RETURN_NULL();
506
507         key_array = PG_GETARG_ARRAYTYPE_P(0);
508
509         Assert(ARR_ELEMTYPE(key_array) == TEXTOID);
510
511         /*
512          * must check >1 rather than != 1 because empty arrays have 0 dimensions,
513          * not 1
514          */
515
516         if (ARR_NDIM(key_array) > 1)
517                 ereport(ERROR,
518                                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
519                                  errmsg("wrong number of array subscripts")));
520
521         deconstruct_array(key_array,
522                                           TEXTOID, -1, false, 'i',
523                                           &key_datums, &key_nulls, &key_count);
524
525         /* see discussion in arrayToHStoreSortedArray() */
526         if (key_count > MaxAllocSize / sizeof(HStorePair))
527                 ereport(ERROR,
528                                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
529                           errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
530                                          key_count, (int) (MaxAllocSize / sizeof(HStorePair)))));
531
532         /* value_array might be NULL */
533
534         if (PG_ARGISNULL(1))
535         {
536                 value_array = NULL;
537                 value_count = key_count;
538                 value_datums = NULL;
539                 value_nulls = NULL;
540         }
541         else
542         {
543                 value_array = PG_GETARG_ARRAYTYPE_P(1);
544
545                 Assert(ARR_ELEMTYPE(value_array) == TEXTOID);
546
547                 if (ARR_NDIM(value_array) > 1)
548                         ereport(ERROR,
549                                         (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
550                                          errmsg("wrong number of array subscripts")));
551
552                 if ((ARR_NDIM(key_array) > 0 || ARR_NDIM(value_array) > 0) &&
553                         (ARR_NDIM(key_array) != ARR_NDIM(value_array) ||
554                          ARR_DIMS(key_array)[0] != ARR_DIMS(value_array)[0] ||
555                          ARR_LBOUND(key_array)[0] != ARR_LBOUND(value_array)[0]))
556                         ereport(ERROR,
557                                         (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
558                                          errmsg("arrays must have same bounds")));
559
560                 deconstruct_array(value_array,
561                                                   TEXTOID, -1, false, 'i',
562                                                   &value_datums, &value_nulls, &value_count);
563
564                 Assert(key_count == value_count);
565         }
566
567         v.type = hsvHash;
568         v.size = 2 * sizeof(HEntry);
569         v.hash.pairs = palloc(key_count * sizeof(*v.hash.pairs));
570         v.hash.npairs = key_count;
571
572         for (i = 0; i < key_count; ++i)
573         {
574                 if (key_nulls[i])
575                         ereport(ERROR,
576                                         (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
577                                          errmsg("null value not allowed for hstore key")));
578
579                 v.hash.pairs[i].key.type = hsvString;
580                 v.hash.pairs[i].key.string.val = VARDATA_ANY(key_datums[i]);
581                 v.hash.pairs[i].key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(key_datums[i]));
582                 v.hash.pairs[i].key.size = sizeof(HEntry) +
583                                                                         v.hash.pairs[i].key.string.len;
584
585                 if (!value_nulls || value_nulls[i])
586                 {
587                         v.hash.pairs[i].value.type = hsvNull;
588                         v.hash.pairs[i].value.size = sizeof(HEntry);
589                 }
590                 else
591                 {
592                         v.hash.pairs[i].value.type = hsvString;
593                         v.hash.pairs[i].value.size = sizeof(HEntry);
594                         v.hash.pairs[i].value.string.val = VARDATA_ANY(value_datums[i]);
595                         v.hash.pairs[i].value.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(value_datums[i]));
596                         v.hash.pairs[i].value.size = sizeof(HEntry) +
597                                                                                         v.hash.pairs[i].value.string.len;
598                 }
599
600                 v.size += v.hash.pairs[i].key.size + v.hash.pairs[i].value.size;
601         }
602
603         uniqueHStoreValue(&v);
604
605
606         PG_RETURN_POINTER(hstoreDump(&v));
607 }
608
609
610 PG_FUNCTION_INFO_V1(hstore_from_array);
611 Datum           hstore_from_array(PG_FUNCTION_ARGS);
612 Datum
613 hstore_from_array(PG_FUNCTION_ARGS)
614 {
615         ArrayType  *in_array = PG_GETARG_ARRAYTYPE_P(0);
616         int                     ndims = ARR_NDIM(in_array);
617         int                     count;
618         HStoreValue     v;
619         Datum      *in_datums;
620         bool       *in_nulls;
621         int                     in_count;
622         int                     i;
623
624         Assert(ARR_ELEMTYPE(in_array) == TEXTOID);
625
626         switch (ndims)
627         {
628                 case 0:
629                         PG_RETURN_POINTER(hstoreDump(NULL));
630
631                 case 1:
632                         if ((ARR_DIMS(in_array)[0]) % 2)
633                                 ereport(ERROR,
634                                                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
635                                                  errmsg("array must have even number of elements")));
636                         break;
637
638                 case 2:
639                         if ((ARR_DIMS(in_array)[1]) != 2)
640                                 ereport(ERROR,
641                                                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
642                                                  errmsg("array must have two columns")));
643                         break;
644
645                 default:
646                         ereport(ERROR,
647                                         (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
648                                          errmsg("wrong number of array subscripts")));
649         }
650
651         deconstruct_array(in_array,
652                                           TEXTOID, -1, false, 'i',
653                                           &in_datums, &in_nulls, &in_count);
654
655         count = in_count / 2;
656
657         /* see discussion in arrayToHStoreSortedArray() */
658         if (count > MaxAllocSize / sizeof(HStorePair))
659                 ereport(ERROR,
660                                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
661                           errmsg("number of pairs (%d) exceeds the maximum allowed (%d)",
662                                          count, (int) (MaxAllocSize / sizeof(HStorePair)))));
663
664         v.type = hsvHash;
665         v.size = 2*sizeof(HEntry);
666         v.hash.npairs = count;
667         v.hash.pairs = palloc(count * sizeof(HStorePair));
668
669         for (i = 0; i < count; ++i)
670         {
671                 if (in_nulls[i * 2])
672                         ereport(ERROR,
673                                         (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
674                                          errmsg("null value not allowed for hstore key")));
675
676                 v.hash.pairs[i].key.type = hsvString;
677                 v.hash.pairs[i].key.string.val = VARDATA_ANY(in_datums[i * 2]);
678                 v.hash.pairs[i].key.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(in_datums[i * 2]));
679                 v.hash.pairs[i].key.size = sizeof(HEntry) +
680                                                                         v.hash.pairs[i].key.string.len;
681
682                 if (in_nulls[i * 2 + 1])
683                 {
684                         v.hash.pairs[i].value.type = hsvNull;
685                         v.hash.pairs[i].value.size = sizeof(HEntry);
686                 }
687                 else
688                 {
689                         v.hash.pairs[i].value.type = hsvString;
690                         v.hash.pairs[i].value.size = sizeof(HEntry);
691                         v.hash.pairs[i].value.string.val = VARDATA_ANY(in_datums[i * 2 + 1]);
692                         v.hash.pairs[i].value.string.len = hstoreCheckKeyLen(VARSIZE_ANY_EXHDR(in_datums[i * 2 + 1]));
693                         v.hash.pairs[i].value.size = sizeof(HEntry) +
694                                                                                         v.hash.pairs[i].value.string.len;
695                 }
696
697                 v.size += v.hash.pairs[i].key.size + v.hash.pairs[i].value.size;
698         }
699
700         uniqueHStoreValue(&v);
701
702         PG_RETURN_POINTER(hstoreDump(&v));
703 }
704
705 /* most of hstore_from_record is shamelessly swiped from record_out */
706
707 /*
708  * structure to cache metadata needed for record I/O
709  */
710 typedef struct ColumnIOData
711 {
712         Oid                     column_type;
713         Oid                     typiofunc;
714         Oid                     typioparam;
715         FmgrInfo        proc;
716 } ColumnIOData;
717
718 typedef struct RecordIOData
719 {
720         Oid                     record_type;
721         int32           record_typmod;
722         int                     ncolumns;
723         ColumnIOData columns[1];        /* VARIABLE LENGTH ARRAY */
724 } RecordIOData;
725
726 PG_FUNCTION_INFO_V1(hstore_from_record);
727 Datum           hstore_from_record(PG_FUNCTION_ARGS);
728 Datum
729 hstore_from_record(PG_FUNCTION_ARGS)
730 {
731         HeapTupleHeader rec;
732         HStore             *out;
733         HStoreValue        v;
734         Oid                             tupType;
735         int32                   tupTypmod;
736         TupleDesc               tupdesc;
737         HeapTupleData   tuple;
738         RecordIOData   *my_extra;
739         int                             ncolumns;
740         int                             i;
741         Datum              *values;
742         bool               *nulls;
743
744         if (PG_ARGISNULL(0))
745         {
746                 Oid                     argtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
747
748                 /*
749                  * have no tuple to look at, so the only source of type info is the
750                  * argtype. The lookup_rowtype_tupdesc call below will error out if we
751                  * don't have a known composite type oid here.
752                  */
753                 tupType = argtype;
754                 tupTypmod = -1;
755
756                 rec = NULL;
757         }
758         else
759         {
760                 rec = PG_GETARG_HEAPTUPLEHEADER(0);
761
762                 /* Extract type info from the tuple itself */
763                 tupType = HeapTupleHeaderGetTypeId(rec);
764                 tupTypmod = HeapTupleHeaderGetTypMod(rec);
765         }
766
767         tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
768         ncolumns = tupdesc->natts;
769
770         /*
771          * We arrange to look up the needed I/O info just once per series of
772          * calls, assuming the record type doesn't change underneath us.
773          */
774         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
775         if (my_extra == NULL ||
776                 my_extra->ncolumns != ncolumns)
777         {
778                 fcinfo->flinfo->fn_extra =
779                         MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
780                                                            sizeof(RecordIOData) - sizeof(ColumnIOData)
781                                                            + ncolumns * sizeof(ColumnIOData));
782                 my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
783                 my_extra->record_type = InvalidOid;
784                 my_extra->record_typmod = 0;
785         }
786
787         if (my_extra->record_type != tupType ||
788                 my_extra->record_typmod != tupTypmod)
789         {
790                 MemSet(my_extra, 0,
791                            sizeof(RecordIOData) - sizeof(ColumnIOData)
792                            + ncolumns * sizeof(ColumnIOData));
793                 my_extra->record_type = tupType;
794                 my_extra->record_typmod = tupTypmod;
795                 my_extra->ncolumns = ncolumns;
796         }
797
798         v.type = hsvHash;
799         v.size = 2*sizeof(HEntry);
800         v.hash.npairs = ncolumns;
801         Assert(ncolumns <= MaxTupleAttributeNumber);            /* thus, no overflow */
802         v.hash.pairs = palloc(ncolumns * sizeof(HStorePair));
803
804         if (rec)
805         {
806                 /* Build a temporary HeapTuple control structure */
807                 tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
808                 ItemPointerSetInvalid(&(tuple.t_self));
809                 tuple.t_tableOid = InvalidOid;
810                 tuple.t_data = rec;
811
812                 values = (Datum *) palloc(ncolumns * sizeof(Datum));
813                 nulls = (bool *) palloc(ncolumns * sizeof(bool));
814
815                 /* Break down the tuple into fields */
816                 heap_deform_tuple(&tuple, tupdesc, values, nulls);
817         }
818         else
819         {
820                 values = NULL;
821                 nulls = NULL;
822         }
823
824         for (i = 0; i < ncolumns; ++i)
825         {
826                 ColumnIOData *column_info = &my_extra->columns[i];
827                 Oid                     column_type = tupdesc->attrs[i]->atttypid;
828                 char       *value;
829
830                 /* Ignore dropped columns in datatype */
831                 if (tupdesc->attrs[i]->attisdropped)
832                         continue;
833
834                 v.hash.pairs[i].key.type = hsvString;
835                 v.hash.pairs[i].key.string.val = NameStr(tupdesc->attrs[i]->attname);
836                 v.hash.pairs[i].key.string.len = hstoreCheckKeyLen(strlen(v.hash.pairs[i].key.string.val));
837                 v.hash.pairs[i].key.size = sizeof(HEntry) +
838                                                                         v.hash.pairs[i].key.string.len;
839
840                 if (!nulls || nulls[i])
841                 {
842                         v.hash.pairs[i].value.type = hsvNull;
843                         v.hash.pairs[i].value.size = sizeof(HEntry);
844                 }
845                 else
846                 {
847                         /*
848                          * Convert the column value to hstore's values
849                          */
850                         if (column_type == BOOLOID)
851                         {
852                                 v.hash.pairs[i].value.type = hsvBool;
853                                 v.hash.pairs[i].value.boolean = DatumGetBool(values[i]);
854                                 v.hash.pairs[i].value.size = sizeof(HEntry);
855                         }
856                         else if (TypeCategory(column_type) == TYPCATEGORY_NUMERIC)
857                         {
858                                 Oid                             castOid = InvalidOid;
859                                 CoercionMethod  method;
860
861                                 v.hash.pairs[i].value.type = hsvNumeric;
862
863                                 castOid = searchCast(column_type, NUMERICOID, &method);
864                                 if (castOid == InvalidOid)
865                                 {
866                                         if (method != COERCION_METHOD_BINARY)
867                                                 elog(ERROR, "Could not cast numeric category type to numeric '%c'", (char)method);
868
869                                         v.hash.pairs[i].value.numeric = DatumGetNumeric(values[i]);
870                                 }
871                                 else
872                                 {
873                                         v.hash.pairs[i].value.numeric = 
874                                                 DatumGetNumeric(OidFunctionCall1(castOid, values[i]));
875
876                                 }
877                                 v.hash.pairs[i].value.size = 2*sizeof(HEntry) +
878                                                                 VARSIZE_ANY(v.hash.pairs[i].value.numeric);
879                         }
880                         else
881                         {
882                                 if (column_info->column_type != column_type)
883                                 {
884                                         bool            typIsVarlena;
885
886                                         getTypeOutputInfo(column_type,
887                                                                           &column_info->typiofunc,
888                                                                           &typIsVarlena);
889                                         fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
890                                                                   fcinfo->flinfo->fn_mcxt);
891                                         column_info->column_type = column_type;
892                                 }
893
894                                 value = OutputFunctionCall(&column_info->proc, values[i]);
895
896                                 v.hash.pairs[i].value.type = hsvString;
897                                 v.hash.pairs[i].value.string.val = value;
898                                 v.hash.pairs[i].value.string.len = hstoreCheckValLen(strlen(value));
899                                 v.hash.pairs[i].value.size = sizeof(HEntry) +
900                                                                                 v.hash.pairs[i].value.string.len;
901                         }
902                 }
903
904                 v.size += v.hash.pairs[i].key.size + v.hash.pairs[i].value.size;
905         }
906
907         uniqueHStoreValue(&v);
908
909         out = hstoreDump(&v);
910
911         ReleaseTupleDesc(tupdesc);
912
913         PG_RETURN_POINTER(out);
914 }
915
916
917 PG_FUNCTION_INFO_V1(hstore_populate_record);
918 Datum           hstore_populate_record(PG_FUNCTION_ARGS);
919 Datum
920 hstore_populate_record(PG_FUNCTION_ARGS)
921 {
922         Oid                     argtype = get_fn_expr_argtype(fcinfo->flinfo, 0);
923         HStore     *hs;
924         HeapTupleHeader rec;
925         Oid                     tupType;
926         int32           tupTypmod;
927         TupleDesc       tupdesc;
928         HeapTupleData tuple;
929         HeapTuple       rettuple;
930         RecordIOData *my_extra;
931         int                     ncolumns;
932         int                     i;
933         Datum      *values;
934         bool       *nulls;
935
936         if (!type_is_rowtype(argtype))
937                 ereport(ERROR,
938                                 (errcode(ERRCODE_DATATYPE_MISMATCH),
939                                  errmsg("first argument must be a rowtype")));
940
941         if (PG_ARGISNULL(0))
942         {
943                 if (PG_ARGISNULL(1))
944                         PG_RETURN_NULL();
945
946                 rec = NULL;
947
948                 /*
949                  * have no tuple to look at, so the only source of type info is the
950                  * argtype. The lookup_rowtype_tupdesc call below will error out if we
951                  * don't have a known composite type oid here.
952                  */
953                 tupType = argtype;
954                 tupTypmod = -1;
955         }
956         else
957         {
958                 rec = PG_GETARG_HEAPTUPLEHEADER(0);
959
960                 if (PG_ARGISNULL(1))
961                         PG_RETURN_POINTER(rec);
962
963                 /* Extract type info from the tuple itself */
964                 tupType = HeapTupleHeaderGetTypeId(rec);
965                 tupTypmod = HeapTupleHeaderGetTypMod(rec);
966         }
967
968         hs = PG_GETARG_HS(1);
969
970         /*
971          * if the input hstore is empty, we can only skip the rest if we were
972          * passed in a non-null record, since otherwise there may be issues with
973          * domain nulls.
974          */
975
976         if (HS_ISEMPTY(hs) && rec)
977                 PG_RETURN_POINTER(rec);
978
979         tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
980         ncolumns = tupdesc->natts;
981
982         if (rec)
983         {
984                 /* Build a temporary HeapTuple control structure */
985                 tuple.t_len = HeapTupleHeaderGetDatumLength(rec);
986                 ItemPointerSetInvalid(&(tuple.t_self));
987                 tuple.t_tableOid = InvalidOid;
988                 tuple.t_data = rec;
989         }
990
991         /*
992          * We arrange to look up the needed I/O info just once per series of
993          * calls, assuming the record type doesn't change underneath us.
994          */
995         my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
996         if (my_extra == NULL ||
997                 my_extra->ncolumns != ncolumns)
998         {
999                 fcinfo->flinfo->fn_extra =
1000                         MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
1001                                                            sizeof(RecordIOData) - sizeof(ColumnIOData)
1002                                                            + ncolumns * sizeof(ColumnIOData));
1003                 my_extra = (RecordIOData *) fcinfo->flinfo->fn_extra;
1004                 my_extra->record_type = InvalidOid;
1005                 my_extra->record_typmod = 0;
1006         }
1007
1008         if (my_extra->record_type != tupType ||
1009                 my_extra->record_typmod != tupTypmod)
1010         {
1011                 MemSet(my_extra, 0,
1012                            sizeof(RecordIOData) - sizeof(ColumnIOData)
1013                            + ncolumns * sizeof(ColumnIOData));
1014                 my_extra->record_type = tupType;
1015                 my_extra->record_typmod = tupTypmod;
1016                 my_extra->ncolumns = ncolumns;
1017         }
1018
1019         values = (Datum *) palloc(ncolumns * sizeof(Datum));
1020         nulls = (bool *) palloc(ncolumns * sizeof(bool));
1021
1022         if (rec)
1023         {
1024                 /* Break down the tuple into fields */
1025                 heap_deform_tuple(&tuple, tupdesc, values, nulls);
1026         }
1027         else
1028         {
1029                 for (i = 0; i < ncolumns; ++i)
1030                 {
1031                         values[i] = (Datum) 0;
1032                         nulls[i] = true;
1033                 }
1034         }
1035
1036         for (i = 0; i < ncolumns; ++i)
1037         {
1038                 ColumnIOData *column_info = &my_extra->columns[i];
1039                 Oid                     column_type = tupdesc->attrs[i]->atttypid;
1040                 HStoreValue     *v = NULL;
1041
1042                 /* Ignore dropped columns in datatype */
1043                 if (tupdesc->attrs[i]->attisdropped)
1044                 {
1045                         nulls[i] = true;
1046                         continue;
1047                 }
1048
1049                 if (!HS_ISEMPTY(hs))
1050                 {
1051                         char *key = NameStr(tupdesc->attrs[i]->attname);
1052
1053                         v = findUncompressedHStoreValue(VARDATA(hs), HS_FLAG_HSTORE, NULL, key, strlen(key));
1054                 }
1055
1056                 /*
1057                  * we can't just skip here if the key wasn't found since we might have
1058                  * a domain to deal with. If we were passed in a non-null record
1059                  * datum, we assume that the existing values are valid (if they're
1060                  * not, then it's not our fault), but if we were passed in a null,
1061                  * then every field which we don't populate needs to be run through
1062                  * the input function just in case it's a domain type.
1063                  */
1064                 if (v == NULL && rec)
1065                         continue;
1066
1067                 /*
1068                  * Prepare to convert the column value from text
1069                  */
1070                 if (column_info->column_type != column_type)
1071                 {
1072                         getTypeInputInfo(column_type,
1073                                                          &column_info->typiofunc,
1074                                                          &column_info->typioparam);
1075                         fmgr_info_cxt(column_info->typiofunc, &column_info->proc,
1076                                                   fcinfo->flinfo->fn_mcxt);
1077                         column_info->column_type = column_type;
1078                 }
1079
1080                 if (v == NULL || v->type == hsvNull)
1081                 {
1082                         /*
1083                          * need InputFunctionCall to happen even for nulls, so that domain
1084                          * checks are done
1085                          */
1086                         values[i] = InputFunctionCall(&column_info->proc, NULL,
1087                                                                                   column_info->typioparam,
1088                                                                                   tupdesc->attrs[i]->atttypmod);
1089                         nulls[i] = true;
1090                 }
1091                 else
1092                 {
1093                         char *s = NULL;
1094
1095                         if (v->type == hsvString)
1096                                 s = pnstrdup(v->string.val, v->string.len);
1097                         else if (v->type == hsvBool)
1098                                 s = pnstrdup((v->boolean) ? "t" : "f", 1);
1099                         else if (v->type == hsvNumeric)
1100                                 s = DatumGetCString(DirectFunctionCall1(numeric_out,
1101                                                                                                                 PointerGetDatum(v->numeric)));
1102                         else if (v->type == hsvBinary && column_type == JSONOID)
1103                                 s = hstoreToCString(NULL, v->binary.data, v->binary.len,
1104                                                                         SET_PRETTY_PRINT_VAR(JsonOutput | RootHashDecorated));
1105                         else if (v->type == hsvBinary && type_is_array(column_type))
1106                                 s = hstoreToCString(NULL, v->binary.data, v->binary.len,
1107                                                                         SET_PRETTY_PRINT_VAR(ArrayCurlyBraces));
1108                         else if (v->type == hsvBinary)
1109                                 s = hstoreToCString(NULL, v->binary.data, v->binary.len,
1110                                                                         SET_PRETTY_PRINT_VAR(0));
1111                         else
1112                                 elog(PANIC, "Wrong hstore");
1113
1114                         values[i] = InputFunctionCall(&column_info->proc, s,
1115                                                                                   column_info->typioparam,
1116                                                                                   tupdesc->attrs[i]->atttypmod);
1117                         nulls[i] = false;
1118                 }
1119         }
1120
1121         rettuple = heap_form_tuple(tupdesc, values, nulls);
1122
1123         ReleaseTupleDesc(tupdesc);
1124
1125         PG_RETURN_DATUM(HeapTupleGetDatum(rettuple));
1126 }
1127
1128 bool
1129 stringIsNumber(char *string, int len, bool jsonNumber) {
1130         enum {
1131                 SIN_FIRSTINT,
1132                 SIN_ZEROINT,
1133                 SIN_INT,
1134                 SIN_SCALE,
1135                 SIN_MSIGN,
1136                 SIN_MANTISSA
1137         } sinState;
1138         char    *c;
1139         bool    r;
1140
1141         if (*string == '-' || *string == '+')
1142         {
1143                 string++;
1144                 len--;
1145         }
1146
1147         c = string;
1148         r = true;
1149         sinState = SIN_FIRSTINT;
1150
1151         while(r && c - string < len)
1152         {
1153                 switch(sinState)
1154                 {
1155                         case SIN_FIRSTINT:
1156                                 if (*c == '0' && jsonNumber)
1157                                         sinState = SIN_ZEROINT;
1158                                 else if (*c == '.')
1159                                         sinState = SIN_SCALE;
1160                                 else if (isdigit(*c))
1161                                         sinState = SIN_INT;
1162                                 else
1163                                         r = false;
1164                                 break;
1165                         case SIN_ZEROINT:
1166                                 if (*c == '.')
1167                                         sinState = SIN_SCALE;
1168                                 else
1169                                         r = false;
1170                                 break;
1171                         case SIN_INT:
1172                                 if (*c == '.')
1173                                         sinState = SIN_SCALE;
1174                                 else if (*c == 'e' || *c == 'E')
1175                                         sinState = SIN_MSIGN;
1176                                 else if (!isdigit(*c))
1177                                         r = false;
1178                                 break;
1179                         case SIN_SCALE:
1180                                 if (*c == 'e' || *c == 'E')
1181                                         sinState = SIN_MSIGN;
1182                                 else if (!isdigit(*c))
1183                                         r = false;
1184                                 break;
1185                         case SIN_MSIGN:
1186                                 if (*c == '-' || *c == '+' || isdigit(*c))
1187                                         sinState = SIN_MANTISSA;
1188                                 else
1189                                         r = false;
1190                                 break;
1191                         case SIN_MANTISSA:
1192                                 if (!isdigit(*c))
1193                                         r = false;
1194                                 break;
1195                         default:
1196                                 abort();
1197                 }
1198
1199                 c++;
1200         }
1201
1202         if (sinState == SIN_MSIGN)
1203                 r = false;
1204
1205         return r;
1206 }
1207
1208 static void
1209 printIndent(StringInfo out, bool isRootHash, HStoreOutputKind kind, int level)
1210 {
1211         if (kind & PrettyPrint)
1212         {
1213                 int i;
1214
1215                 if (isRootHash && (kind & RootHashDecorated) == 0)
1216                         level--;
1217                 for(i=0; i<4*level; i++)
1218                         appendStringInfoCharMacro(out, ' ');
1219         }
1220 }
1221
1222 static void
1223 printCR(StringInfo out, HStoreOutputKind kind)
1224 {
1225         if (kind & PrettyPrint)
1226                 appendStringInfoCharMacro(out, '\n');
1227 }
1228
1229 static void
1230 escape_hstore(StringInfo out, char *string, uint32 len)
1231 {
1232         char       *ptr = string;
1233
1234         appendStringInfoCharMacro(out, '"');
1235         while (ptr - string < len)
1236         {
1237                 if (*ptr == '"' || *ptr == '\\')
1238                         appendStringInfoCharMacro(out, '\\');
1239                 appendStringInfoCharMacro(out, *ptr);
1240                 ptr++;
1241         }
1242         appendStringInfoCharMacro(out, '"');
1243 }
1244
1245 static void
1246 putEscapedString(StringInfo out, HStoreOutputKind kind,
1247                                  char *string, uint32 len)
1248 {
1249         if (kind & LooseOutput)
1250         {
1251                 if (len == 1 && *string == 't')
1252                         appendStringInfoString(out, (kind & JsonOutput) ? "true" : "t" );
1253                 else if (len == 1 && *string == 'f')
1254                         appendStringInfoString(out, (kind & JsonOutput) ? "false" : "f");
1255                 else if (len > 0 && stringIsNumber(string, len, true))
1256                         appendBinaryStringInfo(out, string, len);
1257                 else if (kind & JsonOutput)
1258                         escape_json(out, pnstrdup(string, len));
1259                 else
1260                         escape_hstore(out, string, len);
1261         }
1262         else
1263         {
1264                 if (kind & JsonOutput)
1265                         escape_json(out, pnstrdup(string, len));
1266                 else
1267                         escape_hstore(out, string, len);
1268         }
1269 }
1270
1271 static void
1272 putEscapedValue(StringInfo out, HStoreOutputKind kind, HStoreValue *v)
1273 {
1274         switch(v->type)
1275         {
1276                 case hsvNull:
1277                         appendBinaryStringInfo(out,
1278                                                                    (kind & JsonOutput) ? "null" : "NULL", 4);
1279                         break;
1280                 case hsvString:
1281                         putEscapedString(out, kind, v->string.val, v->string.len);
1282                         break;
1283                 case hsvBool:
1284                         if ((kind & JsonOutput) == 0)
1285                                 appendBinaryStringInfo(out, (v->boolean) ? "t" : "f", 1);
1286                         else if (v->boolean)
1287                                 appendBinaryStringInfo(out, "true", 4);
1288                         else
1289                                 appendBinaryStringInfo(out, "false", 5);
1290                         break;
1291                 case hsvNumeric:
1292                         appendStringInfoString(out, DatumGetCString(DirectFunctionCall1(numeric_out, PointerGetDatum(v->numeric))));
1293                         break;
1294                 default:
1295                         elog(PANIC, "Unknown type");
1296         }
1297 }
1298
1299 static bool
1300 needBrackets(int level, bool isArray, HStoreOutputKind kind, bool isScalar)
1301 {
1302         bool res;
1303
1304         if (isArray && isScalar)
1305                 res = false;
1306         else if (level == 0)
1307                 res = (isArray || (kind & RootHashDecorated)) ? true : false;
1308         else
1309                 res = true;
1310
1311         return res;
1312 }
1313
1314 static bool
1315 isArrayBrackets(HStoreOutputKind kind)
1316 {
1317         return ((kind & ArrayCurlyBraces) == 0) ? true : false;
1318 }
1319
1320
1321 char*
1322 hstoreToCString(StringInfo out, char *in, int len /* just estimation */,
1323                   HStoreOutputKind kind)
1324 {
1325         bool                    first = true;
1326         HStoreIterator  *it;
1327         int                             type;
1328         HStoreValue             v;
1329         int                             level = 0;
1330         bool                    isRootHash = false;
1331
1332         if (out == NULL)
1333                 out = makeStringInfo();
1334
1335         if (in == NULL)
1336         {
1337                 appendStringInfoString(out, "");
1338                 return out->data;
1339         }
1340
1341         enlargeStringInfo(out, (len >= 0) ? len : 64);
1342
1343         it = HStoreIteratorInit(in);
1344
1345         while((type = HStoreIteratorGet(&it, &v, false)) != 0)
1346         {
1347 reout:
1348                 switch(type)
1349                 {
1350                         case WHS_BEGIN_ARRAY:
1351                                 if (first == false)
1352                                 {
1353                                         appendBinaryStringInfo(out, ", ", 2);
1354                                         printCR(out, kind);
1355                                 }
1356                                 first = true;
1357
1358                                 if (needBrackets(level, true, kind, v.array.scalar))
1359                                 {
1360                                         printIndent(out, isRootHash, kind, level);
1361                                         appendStringInfoChar(out, isArrayBrackets(kind) ? '[' : '{');
1362                                         printCR(out, kind);
1363                                 }
1364                                 level++;
1365                                 break;
1366                         case WHS_BEGIN_HASH:
1367                                 if (first == false)
1368                                 {
1369                                         appendBinaryStringInfo(out, ", ", 2);
1370                                         printCR(out, kind);
1371                                 }
1372                                 first = true;
1373
1374                                 if (level == 0)
1375                                         isRootHash = true;
1376
1377                                 if (needBrackets(level, false, kind, false))
1378                                 {
1379                                         printIndent(out, isRootHash, kind, level);
1380                                         appendStringInfoCharMacro(out, '{');
1381                                         printCR(out, kind);
1382                                 }
1383
1384                                 level++;
1385                                 break;
1386                         case WHS_KEY:
1387                                 if (first == false)
1388                                 {
1389                                         appendBinaryStringInfo(out, ", ", 2);
1390                                         printCR(out, kind);
1391                                 }
1392                                 first = true;
1393
1394                                 printIndent(out, isRootHash, kind, level);
1395                                 /* key should not be loose */
1396                                 putEscapedValue(out, kind & ~LooseOutput, &v);
1397                                 appendBinaryStringInfo(out,
1398                                                                            (kind & JsonOutput) ? ": " : "=>", 2);
1399
1400                                 type = HStoreIteratorGet(&it, &v, false);
1401                                 if (type == WHS_VALUE)
1402                                 {
1403                                         first = false;
1404                                         putEscapedValue(out, kind, &v);
1405                                 }
1406                                 else
1407                                 {
1408                                         Assert(type == WHS_BEGIN_HASH || type == WHS_BEGIN_ARRAY);
1409                                         printCR(out, kind);
1410                                         /*
1411                                          * We need to rerun current switch() due to put
1412                                          * in current place object which we just got
1413                                          * from iterator.
1414                                          */
1415                                         goto reout;
1416                                 }
1417                                 break;
1418                         case WHS_ELEM:
1419                                 if (first == false)
1420                                 {
1421                                         appendBinaryStringInfo(out, ", ", 2);
1422                                         printCR(out, kind);
1423                                 }
1424                                 else
1425                                 {
1426                                         first = false;
1427                                 }
1428
1429                                 printIndent(out, isRootHash, kind, level);
1430                                 putEscapedValue(out, kind, &v);
1431                                 break;
1432                         case WHS_END_ARRAY:
1433                                 level--;
1434                                 if (needBrackets(level, true, kind, v.array.scalar))
1435                                 {
1436                                         printCR(out, kind);
1437                                         printIndent(out, isRootHash, kind, level);
1438                                         appendStringInfoChar(out, isArrayBrackets(kind) ? ']' : '}');
1439                                 }
1440                                 first = false;
1441                                 break;
1442                         case WHS_END_HASH:
1443                                 level--;
1444                                 if (needBrackets(level, false, kind, false))
1445                                 {
1446                                         printCR(out, kind);
1447                                         printIndent(out, isRootHash, kind, level);
1448                                         appendStringInfoCharMacro(out, '}');
1449                                 }
1450                                 first = false;
1451                                 break;
1452                         default:
1453                                 elog(PANIC, "Wrong flags");
1454                 }
1455         }
1456
1457         Assert(level == 0);
1458
1459         return out->data;
1460 }
1461
1462 text*
1463 HStoreValueToText(HStoreValue *v)
1464 {
1465         text            *out;
1466
1467         if (v == NULL || v->type == hsvNull)
1468         {
1469                 out = NULL;
1470         }
1471         else if (v->type == hsvString)
1472         {
1473                 out = cstring_to_text_with_len(v->string.val, v->string.len);
1474         }
1475         else if (v->type == hsvBool)
1476         {
1477                 out = cstring_to_text_with_len((v->boolean) ? "t" : "f", 1);
1478         }
1479         else if (v->type == hsvNumeric)
1480         {
1481                 out = cstring_to_text(DatumGetCString(
1482                                 DirectFunctionCall1(numeric_out, PointerGetDatum(v->numeric))
1483                 ));
1484         }
1485         else
1486         {
1487                 StringInfo      str;
1488
1489                 str = makeStringInfo();
1490                 appendBinaryStringInfo(str, "    ", 4); /* VARHDRSZ */
1491
1492                 hstoreToCString(str, v->binary.data, v->binary.len,
1493                                                 SET_PRETTY_PRINT_VAR(0));
1494
1495                 out = (text*)str->data;
1496                 SET_VARSIZE(out, str->len);
1497         }
1498
1499         return out;
1500 }
1501
1502 PG_FUNCTION_INFO_V1(hstore_out);
1503 Datum           hstore_out(PG_FUNCTION_ARGS);
1504 Datum
1505 hstore_out(PG_FUNCTION_ARGS)
1506 {
1507         HStore  *hs = PG_GETARG_HS(0);
1508         char    *out;
1509
1510         out = hstoreToCString(NULL, (HS_ISEMPTY(hs)) ? NULL : VARDATA(hs),
1511                                                   VARSIZE(hs), SET_PRETTY_PRINT_VAR(0));
1512
1513         PG_RETURN_CSTRING(out);
1514 }
1515
1516 PG_FUNCTION_INFO_V1(hstore_send);
1517 Datum           hstore_send(PG_FUNCTION_ARGS);
1518 Datum
1519 hstore_send(PG_FUNCTION_ARGS)
1520 {
1521         HStore                  *in = PG_GETARG_HS(0);
1522         StringInfoData  buf;
1523
1524         pq_begintypsend(&buf);
1525
1526         if (HS_ISEMPTY(in))
1527         {
1528                 pq_sendint(&buf, 0, 4);
1529         }
1530         else
1531         {
1532                 HStoreIterator  *it;
1533                 int                             type;
1534                 HStoreValue             v;
1535                 uint32                  flag;
1536                 bytea                   *nbuf;
1537
1538                 enlargeStringInfo(&buf, VARSIZE_ANY(in) /* just estimation */);
1539
1540                 it = HStoreIteratorInit(VARDATA_ANY(in));
1541
1542                 while((type = HStoreIteratorGet(&it, &v, false)) != 0)
1543                 {
1544                         switch(type)
1545                         {
1546                                 case WHS_BEGIN_ARRAY:
1547                                         flag = (v.array.scalar) ? HENTRY_ISSCALAR : HENTRY_ISARRAY;
1548                                         pq_sendint(&buf, v.array.nelems | flag, 4);
1549                                         break;
1550                                 case WHS_BEGIN_HASH:
1551                                         pq_sendint(&buf, v.hash.npairs | HENTRY_ISHASH, 4);
1552                                         break;
1553                                 case WHS_KEY:
1554                                         pq_sendint(&buf, v.string.len | HENTRY_ISSTRING, 4);
1555                                         pq_sendtext(&buf, v.string.val, v.string.len);
1556                                         break;
1557                                 case WHS_ELEM:
1558                                 case WHS_VALUE:
1559                                         switch(v.type)
1560                                         {
1561                                                 case hsvNull:
1562                                                         pq_sendint(&buf, HENTRY_ISNULL, 4);
1563                                                         break;
1564                                                 case hsvString:
1565                                                         pq_sendint(&buf, v.string.len | HENTRY_ISSTRING, 4);
1566                                                         pq_sendtext(&buf, v.string.val, v.string.len);
1567                                                         break;
1568                                                 case hsvBool:
1569                                                         pq_sendint(&buf, (v.boolean) ? HENTRY_ISTRUE : HENTRY_ISFALSE, 4);
1570                                                         break;
1571                                                 case hsvNumeric:
1572                                                         nbuf = DatumGetByteaP(DirectFunctionCall1(numeric_send, NumericGetDatum(v.numeric)));
1573                                                         pq_sendint(&buf, ((int)VARSIZE_ANY_EXHDR(nbuf)) | HENTRY_ISNUMERIC, 4);
1574                                                         pq_sendbytes(&buf, VARDATA(nbuf), (int)VARSIZE_ANY_EXHDR(nbuf));
1575                                                         break;
1576                                                 default:
1577                                                         elog(PANIC, "Wrong type: %u", v.type);
1578                                         }
1579                                         break;
1580                                 case WHS_END_ARRAY:
1581                                 case WHS_END_HASH:
1582                                         break;
1583                                 default:
1584                                         elog(PANIC, "Wrong flags");
1585                         }
1586                 }
1587         }
1588
1589         PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
1590 }
1591
1592
1593 /*
1594  * hstore_to_json_loose
1595  *
1596  * This is a heuristic conversion to json which treats
1597  * 't' and 'f' as booleans and strings that look like numbers as numbers,
1598  * as long as they don't start with a leading zero followed by another digit
1599  * (think zip codes or phone numbers starting with 0).
1600  */
1601 PG_FUNCTION_INFO_V1(hstore_to_json_loose);
1602 Datum           hstore_to_json_loose(PG_FUNCTION_ARGS);
1603 Datum
1604 hstore_to_json_loose(PG_FUNCTION_ARGS)
1605 {
1606         HStore     *in = PG_GETARG_HS(0);
1607         text       *out;
1608
1609         if (HS_ISEMPTY(in))
1610         {
1611                 out = cstring_to_text_with_len("{}",2);
1612         }
1613         else
1614         {
1615                 StringInfo      str;
1616
1617                 str = makeStringInfo();
1618                 appendBinaryStringInfo(str, "    ", 4); /* VARHDRSZ */
1619
1620                 hstoreToCString(str, VARDATA_ANY(in), VARSIZE_ANY(in),
1621                                                 SET_PRETTY_PRINT_VAR(JsonOutput | RootHashDecorated | LooseOutput));
1622
1623                 out = (text*)str->data;
1624
1625                 SET_VARSIZE(out, str->len);
1626         }
1627
1628         PG_RETURN_TEXT_P(out);
1629 }
1630
1631 PG_FUNCTION_INFO_V1(hstore_to_json);
1632 Datum           hstore_to_json(PG_FUNCTION_ARGS);
1633 Datum
1634 hstore_to_json(PG_FUNCTION_ARGS)
1635 {
1636         HStore     *in = PG_GETARG_HS(0);
1637         text       *out;
1638
1639         if (HS_ISEMPTY(in))
1640         {
1641                 out = cstring_to_text_with_len("{}",2);
1642         }
1643         else
1644         {
1645                 StringInfo      str;
1646
1647                 str = makeStringInfo();
1648                 appendBinaryStringInfo(str, "    ", 4); /* VARHDRSZ */
1649
1650                 hstoreToCString(str,
1651                                                 HS_ISEMPTY(in) ? NULL : VARDATA_ANY(in),
1652                                                 VARSIZE_ANY(in),
1653                                                 SET_PRETTY_PRINT_VAR(JsonOutput | RootHashDecorated));
1654
1655                 out = (text*)str->data;
1656
1657                 SET_VARSIZE(out, str->len);
1658         }
1659
1660         PG_RETURN_TEXT_P(out);
1661 }
1662
1663 PG_FUNCTION_INFO_V1(json_to_hstore);
1664 Datum           json_to_hstore(PG_FUNCTION_ARGS);
1665 Datum
1666 json_to_hstore(PG_FUNCTION_ARGS)
1667 {
1668         text    *json = PG_GETARG_TEXT_PP(0);
1669
1670         PG_RETURN_POINTER(hstoreDump(parseHStore(VARDATA_ANY(json),
1671                                                                                          VARSIZE_ANY_EXHDR(json), true)));
1672 }
1673
1674 static Oid
1675 searchCast(Oid src, Oid dst, CoercionMethod *method)
1676 {
1677         Oid                             funcOid = InvalidOid,
1678                                         baseSrc;
1679         HeapTuple       tuple;
1680
1681         if (src == dst)
1682         {
1683                 *method = COERCION_METHOD_BINARY;
1684                 return InvalidOid;
1685         }
1686
1687         tuple = SearchSysCache2(CASTSOURCETARGET,
1688                                                         ObjectIdGetDatum(src),
1689                                                         ObjectIdGetDatum(dst));
1690
1691         *method = 0;
1692
1693         if (HeapTupleIsValid(tuple))
1694         {
1695                 Form_pg_cast    castForm = (Form_pg_cast) GETSTRUCT(tuple);
1696
1697                 if (castForm->castmethod == COERCION_METHOD_FUNCTION)
1698                         funcOid = castForm->castfunc;
1699
1700                 *method = castForm->castmethod;
1701
1702                 ReleaseSysCache(tuple);
1703         }
1704         else if ((baseSrc = getBaseType(src)) != src && OidIsValid(baseSrc))
1705         {       
1706                 /* domain type */
1707                 funcOid = searchCast(baseSrc, dst, method);
1708         }
1709
1710         return funcOid;
1711 }
1712
1713 PG_FUNCTION_INFO_V1(array_to_hstore);
1714 Datum           array_to_hstore(PG_FUNCTION_ARGS);
1715 Datum
1716 array_to_hstore(PG_FUNCTION_ARGS)
1717 {
1718         ArrayType               *array = PG_GETARG_ARRAYTYPE_P(0);
1719         ArrayIterator   iterator;
1720         int                             i = 0;
1721         Datum                   datum;
1722         bool                    isnull;
1723         int                             ncounters = ARR_NDIM(array),
1724                                         *counters = palloc0(sizeof(*counters) * ncounters),
1725                                         *dims = ARR_DIMS(array);
1726         ToHStoreState   *state = NULL;
1727         HStoreValue             value, *result;
1728         Oid                             castOid = InvalidOid;
1729         int                             valueType = hsvString;
1730         FmgrInfo                castInfo;
1731         CoercionMethod  method;
1732
1733         if (ArrayGetNItems(ARR_NDIM(array), ARR_DIMS(array)) == 0)
1734                 PG_RETURN_POINTER(hstoreDump(NULL));
1735
1736         switch(ARR_ELEMTYPE(array))
1737         {
1738                 case BOOLOID:
1739                         valueType = hsvBool;
1740                         break;
1741                 case NUMERICOID:
1742                         valueType = hsvNumeric;
1743                         break;
1744                 case TEXTOID:
1745                         valueType = hsvString;
1746                         break;
1747                 default:
1748                         if (TypeCategory(ARR_ELEMTYPE(array)) == TYPCATEGORY_NUMERIC)
1749                         {
1750                                 castOid = searchCast(ARR_ELEMTYPE(array), NUMERICOID, &method);
1751
1752                                 if (castOid == InvalidOid && method != COERCION_METHOD_BINARY)
1753                                         elog(ERROR, "Could not cast array's element type to numeric");
1754
1755                                 valueType = hsvNumeric;
1756                                 break;
1757                         }
1758                         else
1759                         {
1760                                 castOid = searchCast(ARR_ELEMTYPE(array), TEXTOID, &method);
1761
1762                                 if (castOid == InvalidOid && method != COERCION_METHOD_BINARY)
1763                                         elog(ERROR, "Could not cast array's element type to text");
1764
1765                                 valueType = hsvString;
1766                                 break;
1767                         }
1768         }
1769
1770         if (castOid != InvalidOid)
1771                 fmgr_info(castOid, &castInfo);
1772
1773         iterator = array_create_iterator(array, 0);
1774
1775         value.type = hsvArray;
1776         value.array.scalar = false;
1777         for(i=0; i<ncounters; i++)
1778         {
1779                 value.array.nelems = dims[i];
1780                 result = pushHStoreValue(&state, WHS_BEGIN_ARRAY, &value);
1781         }
1782
1783         while(array_iterate(iterator, &datum, &isnull))
1784         {
1785                 i = ncounters - 1;
1786
1787                 if (counters[i] >= dims[i])
1788                 {
1789                         while(i>=0 && counters[i] >= dims[i])
1790                         {
1791                                 counters[i] = 0;
1792                                 result = pushHStoreValue(&state, WHS_END_ARRAY, NULL);
1793                                 i--;
1794                         }
1795
1796                         Assert(i>=0);
1797
1798                         counters[i]++;
1799
1800                         value.type = hsvArray;
1801                         value.array.scalar = false;
1802                         for(i = i + 1; i<ncounters; i++)
1803                         {
1804                                 counters[i] = 1;
1805                                 value.array.nelems = dims[i];
1806                                 result = pushHStoreValue(&state, WHS_BEGIN_ARRAY, &value);
1807                         }
1808                 }
1809                 else
1810                 {
1811                         counters[i]++;
1812                 }
1813
1814                 if (isnull)
1815                 {
1816                         value.type = hsvNull;
1817                         value.size = sizeof(HEntry);
1818                 }
1819                 else
1820                 {
1821                         value.type = valueType;
1822                         switch(valueType)
1823                         {
1824                                 case hsvBool:
1825                                         value.boolean = DatumGetBool(datum);
1826                                         value.size = sizeof(HEntry);
1827                                         break;
1828                                 case hsvString:
1829                                         if (castOid != InvalidOid)
1830                                                 datum = FunctionCall1(&castInfo, datum);
1831                                         value.string.val = VARDATA_ANY(datum);
1832                                         value.string.len = VARSIZE_ANY_EXHDR(datum);
1833                                         value.size = sizeof(HEntry) + value.string.len;
1834                                         break;
1835                                 case hsvNumeric:
1836                                         if (castOid != InvalidOid)
1837                                                 datum = FunctionCall1(&castInfo, datum);
1838                                         value.numeric = DatumGetNumeric(datum);
1839                                         value.size = sizeof(HEntry)*2 + VARSIZE_ANY(value.numeric);
1840                                         break;
1841                                 default:
1842                                         elog(ERROR, "Impossible state: %d", valueType);
1843                         }
1844                 }
1845
1846                 result = pushHStoreValue(&state, WHS_ELEM, &value);
1847         }
1848
1849         for(i=0; i<ncounters; i++)
1850                 result = pushHStoreValue(&state, WHS_END_ARRAY, NULL);
1851
1852         PG_RETURN_POINTER(hstoreDump(result));
1853 }
1854
1855 PG_FUNCTION_INFO_V1(hstore_print);
1856 Datum           hstore_print(PG_FUNCTION_ARGS);
1857 Datum
1858 hstore_print(PG_FUNCTION_ARGS)
1859 {
1860         HStore          *hs = PG_GETARG_HS(0);
1861         int             flags = 0;
1862         text            *out;
1863         StringInfo      str;
1864
1865         if (PG_GETARG_BOOL(1))
1866                 flags |= PrettyPrint;
1867         if (PG_GETARG_BOOL(2))
1868                 flags |= ArrayCurlyBraces;
1869         if (PG_GETARG_BOOL(3))
1870                 flags |= RootHashDecorated;
1871         if (PG_GETARG_BOOL(4))
1872                 flags |= JsonOutput;
1873         if (PG_GETARG_BOOL(5))
1874                 flags |= LooseOutput;
1875
1876         str = makeStringInfo();
1877         appendBinaryStringInfo(str, "    ", 4); /* VARHDRSZ */
1878
1879         hstoreToCString(str, (HS_ISEMPTY(hs)) ? NULL : VARDATA(hs),
1880                                         VARSIZE(hs), flags);
1881
1882         out = (text*)str->data;
1883         SET_VARSIZE(out, str->len);
1884
1885         PG_RETURN_TEXT_P(out);
1886 }
1887
1888 void _PG_init(void);
1889 void
1890 _PG_init(void)
1891 {
1892         DefineCustomBoolVariable(
1893                 "hstore.pretty_print",
1894                 "Enable pretty print",
1895                 "Enable pretty print of hstore type",
1896                 &pretty_print_var,
1897                 pretty_print_var,
1898                 PGC_USERSET,
1899                 GUC_NOT_IN_SAMPLE,
1900                 NULL,
1901                 NULL,
1902                 NULL
1903         );
1904
1905         EmitWarningsOnPlaceholders("hstore");
1906 }