Branch data Line data Source code
1 : : #include "postgres.h"
2 : :
3 : : #include <math.h>
4 : :
5 : : #include "fmgr.h"
6 : : #include "miscadmin.h"
7 : : #include "plperl.h"
8 : : #include "utils/fmgrprotos.h"
9 : : #include "utils/jsonb.h"
10 : :
11 : 2 : PG_MODULE_MAGIC_EXT(
12 : : .name = "jsonb_plperl",
13 : : .version = PG_VERSION
14 : : );
15 : :
16 : : static SV *Jsonb_to_SV(JsonbContainer *jsonb);
17 : : static void SV_to_JsonbValue(SV *in, JsonbInState *jsonb_state, bool is_elem);
18 : :
19 : :
20 : : static SV *
21 : 81 : JsonbValue_to_SV(JsonbValue *jbv)
22 : : {
23 : 81 : dTHX;
24 : :
25 [ + + + + : 81 : switch (jbv->type)
+ - ]
26 : : {
27 : 6 : case jbvBinary:
28 : 6 : return Jsonb_to_SV(jbv->val.binary.data);
29 : :
30 : 49 : case jbvNumeric:
31 : : {
32 : 49 : char *str = DatumGetCString(DirectFunctionCall1(numeric_out,
33 : : NumericGetDatum(jbv->val.numeric)));
34 : 49 : SV *result = newSVnv(SvNV(cstr2sv(str)));
35 : :
36 : 49 : pfree(str);
37 : 49 : return result;
38 : : }
39 : :
40 : 14 : case jbvString:
41 : : {
42 : 14 : char *str = pnstrdup(jbv->val.string.val,
43 : 14 : jbv->val.string.len);
44 : 14 : SV *result = cstr2sv(str);
45 : :
46 : 14 : pfree(str);
47 : 14 : return result;
48 : : }
49 : :
50 : 4 : case jbvBool:
51 [ + + ]: 4 : return newSVnv(SvNV(jbv->val.boolean ? &PL_sv_yes : &PL_sv_no));
52 : :
53 : 8 : case jbvNull:
54 : 8 : return newSV(0);
55 : :
56 : 0 : default:
57 [ # # ]: 0 : elog(ERROR, "unexpected jsonb value type: %d", jbv->type);
58 : : return NULL;
59 : : }
60 : : }
61 : :
62 : : static SV *
63 : 57 : Jsonb_to_SV(JsonbContainer *jsonb)
64 : : {
65 : 57 : dTHX;
66 : : JsonbValue v;
67 : : JsonbIterator *it;
68 : : JsonbIteratorToken r;
69 : :
70 : : /* this can recurse via JsonbValue_to_SV() */
71 : 57 : check_stack_depth();
72 : :
73 : 57 : it = JsonbIteratorInit(jsonb);
74 : 57 : r = JsonbIteratorNext(&it, &v, true);
75 : :
76 [ + + - ]: 57 : switch (r)
77 : : {
78 : 39 : case WJB_BEGIN_ARRAY:
79 [ + + ]: 39 : if (v.val.array.rawScalar)
80 : : {
81 : : JsonbValue tmp;
82 : :
83 [ + - + - ]: 38 : if ((r = JsonbIteratorNext(&it, &v, true)) != WJB_ELEM ||
84 [ - + ]: 38 : (r = JsonbIteratorNext(&it, &tmp, true)) != WJB_END_ARRAY ||
85 : 19 : (r = JsonbIteratorNext(&it, &tmp, true)) != WJB_DONE)
86 [ # # ]: 0 : elog(ERROR, "unexpected jsonb token: %d", r);
87 : :
88 : 19 : return JsonbValue_to_SV(&v);
89 : : }
90 : : else
91 : : {
92 : 20 : AV *av = newAV();
93 : :
94 [ + + ]: 104 : while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
95 : : {
96 [ + + ]: 64 : if (r == WJB_ELEM)
97 : 44 : av_push(av, JsonbValue_to_SV(&v));
98 : : }
99 : :
100 : 20 : return newRV((SV *) av);
101 : : }
102 : :
103 : 18 : case WJB_BEGIN_OBJECT:
104 : : {
105 : 18 : HV *hv = newHV();
106 : :
107 [ + + ]: 72 : while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
108 : : {
109 [ + + ]: 36 : if (r == WJB_KEY)
110 : : {
111 : : /* json key in v, json value in val */
112 : : JsonbValue val;
113 : :
114 [ + - ]: 18 : if (JsonbIteratorNext(&it, &val, true) == WJB_VALUE)
115 : : {
116 : 18 : SV *value = JsonbValue_to_SV(&val);
117 : :
118 : 18 : (void) hv_store(hv,
119 : : v.val.string.val, v.val.string.len,
120 : : value, 0);
121 : : }
122 : : }
123 : : }
124 : :
125 : 18 : return newRV((SV *) hv);
126 : : }
127 : :
128 : 0 : default:
129 [ # # ]: 0 : elog(ERROR, "unexpected jsonb token: %d", r);
130 : : return NULL;
131 : : }
132 : : }
133 : :
134 : : static void
135 : 22 : AV_to_JsonbValue(AV *in, JsonbInState *jsonb_state)
136 : : {
137 : 22 : dTHX;
138 : 22 : SSize_t pcount = av_len(in) + 1;
139 : : SSize_t i;
140 : :
141 : 22 : pushJsonbValue(jsonb_state, WJB_BEGIN_ARRAY, NULL);
142 : :
143 [ + + ]: 70 : for (i = 0; i < pcount; i++)
144 : : {
145 : 48 : SV **value = av_fetch(in, i, FALSE);
146 : :
147 [ + - ]: 48 : if (value)
148 : 48 : SV_to_JsonbValue(*value, jsonb_state, true);
149 : : }
150 : :
151 : 22 : pushJsonbValue(jsonb_state, WJB_END_ARRAY, NULL);
152 : 22 : }
153 : :
154 : : static void
155 : 28 : HV_to_JsonbValue(HV *obj, JsonbInState *jsonb_state)
156 : : {
157 : 28 : dTHX;
158 : : JsonbValue key;
159 : : SV *val;
160 : : char *kstr;
161 : : I32 klen;
162 : :
163 : 28 : key.type = jbvString;
164 : :
165 : 28 : pushJsonbValue(jsonb_state, WJB_BEGIN_OBJECT, NULL);
166 : :
167 : 28 : (void) hv_iterinit(obj);
168 : :
169 [ + + ]: 64 : while ((val = hv_iternextsv(obj, &kstr, &klen)))
170 : : {
171 : 36 : key.val.string.val = pnstrdup(kstr, klen);
172 : 36 : key.val.string.len = klen;
173 : 36 : pushJsonbValue(jsonb_state, WJB_KEY, &key);
174 : 36 : SV_to_JsonbValue(val, jsonb_state, false);
175 : : }
176 : :
177 : 28 : pushJsonbValue(jsonb_state, WJB_END_OBJECT, NULL);
178 : 28 : }
179 : :
180 : : static void
181 : 147 : SV_to_JsonbValue(SV *in, JsonbInState *jsonb_state, bool is_elem)
182 : : {
183 : 147 : dTHX;
184 : : JsonbValue out; /* result */
185 : :
186 : : /* this can recurse via AV_to_JsonbValue() or HV_to_JsonbValue() */
187 : 147 : check_stack_depth();
188 : :
189 : : /* Dereference references recursively. */
190 [ + + ]: 197 : while (SvROK(in))
191 : : {
192 : : /*
193 : : * It's possible for circular references to make this an infinite
194 : : * loop. Checking for such a situation seems like much more trouble
195 : : * than it's worth, but let's provide a way to break out of the loop.
196 : : */
197 [ - + ]: 50 : CHECK_FOR_INTERRUPTS();
198 : 50 : in = SvRV(in);
199 : : }
200 : :
201 [ + + + ]: 147 : switch (SvTYPE(in))
202 : : {
203 : 22 : case SVt_PVAV:
204 : 22 : AV_to_JsonbValue((AV *) in, jsonb_state);
205 : 50 : return;
206 : :
207 : 28 : case SVt_PVHV:
208 : 28 : HV_to_JsonbValue((HV *) in, jsonb_state);
209 : 28 : return;
210 : :
211 : 97 : default:
212 [ + + ]: 97 : if (!SvOK(in))
213 : : {
214 : 12 : out.type = jbvNull;
215 : : }
216 [ + + ]: 85 : else if (SvUOK(in))
217 : : {
218 : : /*
219 : : * If UV is >=64 bits, we have no better way to make this
220 : : * happen than converting to text and back. Given the low
221 : : * usage of UV in Perl code, it's not clear it's worth working
222 : : * hard to provide alternate code paths.
223 : : */
224 : 2 : const char *strval = SvPV_nolen(in);
225 : :
226 : 2 : out.type = jbvNumeric;
227 : 2 : out.val.numeric =
228 : 2 : DatumGetNumeric(DirectFunctionCall3(numeric_in,
229 : : CStringGetDatum(strval),
230 : : ObjectIdGetDatum(InvalidOid),
231 : : Int32GetDatum(-1)));
232 : : }
233 [ + + ]: 83 : else if (SvIOK(in))
234 : : {
235 : 10 : IV ival = SvIV(in);
236 : :
237 : 10 : out.type = jbvNumeric;
238 : 10 : out.val.numeric = int64_to_numeric(ival);
239 : : }
240 [ + + ]: 73 : else if (SvNOK(in))
241 : : {
242 : 53 : double nval = SvNV(in);
243 : :
244 : : /*
245 : : * jsonb doesn't allow infinity or NaN (per JSON
246 : : * specification), but the numeric type that is used for the
247 : : * storage accepts those, so we have to reject them here
248 : : * explicitly.
249 : : */
250 [ + + ]: 53 : if (isinf(nval))
251 [ + - ]: 1 : ereport(ERROR,
252 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
253 : : errmsg("cannot convert infinity to jsonb")));
254 [ - + ]: 52 : if (isnan(nval))
255 [ # # ]: 0 : ereport(ERROR,
256 : : (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
257 : : errmsg("cannot convert NaN to jsonb")));
258 : :
259 : 52 : out.type = jbvNumeric;
260 : 52 : out.val.numeric =
261 : 52 : DatumGetNumeric(DirectFunctionCall1(float8_numeric,
262 : : Float8GetDatum(nval)));
263 : : }
264 [ + - ]: 20 : else if (SvPOK(in))
265 : : {
266 : 20 : out.type = jbvString;
267 : 20 : out.val.string.val = sv2cstr(in);
268 : 20 : out.val.string.len = strlen(out.val.string.val);
269 : : }
270 : : else
271 : : {
272 : : /*
273 : : * XXX It might be nice if we could include the Perl type in
274 : : * the error message.
275 : : */
276 [ # # ]: 0 : ereport(ERROR,
277 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
278 : : errmsg("cannot transform this Perl type to jsonb")));
279 : : }
280 : : }
281 : :
282 [ + + ]: 96 : if (jsonb_state->parseState)
283 : : {
284 : : /* We're in an array or object, so push value as element or field. */
285 [ + + ]: 74 : pushJsonbValue(jsonb_state, is_elem ? WJB_ELEM : WJB_VALUE, &out);
286 : : }
287 : : else
288 : : {
289 : : /*
290 : : * We are at top level, so it's a raw scalar. If we just shove the
291 : : * scalar value into jsonb_state->result, JsonbValueToJsonb will take
292 : : * care of wrapping it into a dummy array.
293 : : */
294 : 22 : jsonb_state->result = palloc_object(JsonbValue);
295 : 22 : memcpy(jsonb_state->result, &out, sizeof(JsonbValue));
296 : : }
297 : : }
298 : :
299 : :
300 : 4 : PG_FUNCTION_INFO_V1(jsonb_to_plperl);
301 : :
302 : : Datum
303 : 51 : jsonb_to_plperl(PG_FUNCTION_ARGS)
304 : : {
305 : 51 : dTHX;
306 : 51 : Jsonb *in = PG_GETARG_JSONB_P(0);
307 : 51 : SV *sv = Jsonb_to_SV(&in->root);
308 : :
309 : 51 : return PointerGetDatum(sv);
310 : : }
311 : :
312 : :
313 : 4 : PG_FUNCTION_INFO_V1(plperl_to_jsonb);
314 : :
315 : : Datum
316 : 63 : plperl_to_jsonb(PG_FUNCTION_ARGS)
317 : : {
318 : 63 : dTHX;
319 : 63 : SV *in = (SV *) PG_GETARG_POINTER(0);
320 : 63 : JsonbInState jsonb_state = {0};
321 : :
322 : 63 : SV_to_JsonbValue(in, &jsonb_state, true);
323 : 62 : PG_RETURN_JSONB_P(JsonbValueToJsonb(jsonb_state.result));
324 : : }
|
