LCOV - code coverage report
Current view: top level - contrib/jsonb_plpython - jsonb_plpython.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12devel Lines: 136 151 90.1 %
Date: 2018-11-13 18:21:17 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #include "postgres.h"
       2             : 
       3             : #include "plpython.h"
       4             : #include "plpy_elog.h"
       5             : #include "plpy_typeio.h"
       6             : #include "utils/jsonb.h"
       7             : #include "utils/fmgrprotos.h"
       8             : #include "utils/numeric.h"
       9             : 
      10           4 : PG_MODULE_MAGIC;
      11             : 
      12             : void        _PG_init(void);
      13             : 
      14             : /* for PLyObject_AsString in plpy_typeio.c */
      15             : typedef char *(*PLyObject_AsString_t) (PyObject *plrv);
      16             : static PLyObject_AsString_t PLyObject_AsString_p;
      17             : 
      18             : typedef void (*PLy_elog_impl_t) (int elevel, const char *fmt,...);
      19             : static PLy_elog_impl_t PLy_elog_impl_p;
      20             : 
      21             : /*
      22             :  * decimal_constructor is a function from python library and used
      23             :  * for transforming strings into python decimal type
      24             :  */
      25             : static PyObject *decimal_constructor;
      26             : 
      27             : static PyObject *PLyObject_FromJsonbContainer(JsonbContainer *jsonb);
      28             : static JsonbValue *PLyObject_ToJsonbValue(PyObject *obj,
      29             :                        JsonbParseState **jsonb_state, bool is_elem);
      30             : 
      31             : #if PY_MAJOR_VERSION >= 3
      32             : typedef PyObject *(*PLyUnicode_FromStringAndSize_t)
      33             :             (const char *s, Py_ssize_t size);
      34             : static PLyUnicode_FromStringAndSize_t PLyUnicode_FromStringAndSize_p;
      35             : #endif
      36             : 
      37             : /*
      38             :  * Module initialize function: fetch function pointers for cross-module calls.
      39             :  */
      40             : void
      41           4 : _PG_init(void)
      42             : {
      43             :     /* Asserts verify that typedefs above match original declarations */
      44             :     AssertVariableIsOfType(&PLyObject_AsString, PLyObject_AsString_t);
      45           4 :     PLyObject_AsString_p = (PLyObject_AsString_t)
      46           4 :         load_external_function("$libdir/" PLPYTHON_LIBNAME, "PLyObject_AsString",
      47             :                                true, NULL);
      48             : #if PY_MAJOR_VERSION >= 3
      49             :     AssertVariableIsOfType(&PLyUnicode_FromStringAndSize, PLyUnicode_FromStringAndSize_t);
      50             :     PLyUnicode_FromStringAndSize_p = (PLyUnicode_FromStringAndSize_t)
      51             :         load_external_function("$libdir/" PLPYTHON_LIBNAME, "PLyUnicode_FromStringAndSize",
      52             :                                true, NULL);
      53             : #endif
      54             : 
      55             :     AssertVariableIsOfType(&PLy_elog_impl, PLy_elog_impl_t);
      56           4 :     PLy_elog_impl_p = (PLy_elog_impl_t)
      57           4 :         load_external_function("$libdir/" PLPYTHON_LIBNAME, "PLy_elog_impl",
      58             :                                true, NULL);
      59           4 : }
      60             : 
      61             : /* These defines must be after the _PG_init */
      62             : #define PLyObject_AsString (PLyObject_AsString_p)
      63             : #define PLyUnicode_FromStringAndSize (PLyUnicode_FromStringAndSize_p)
      64             : #undef PLy_elog
      65             : #define PLy_elog (PLy_elog_impl_p)
      66             : 
      67             : /*
      68             :  * PLyString_FromJsonbValue
      69             :  *
      70             :  * Transform string JsonbValue to Python string.
      71             :  */
      72             : static PyObject *
      73          42 : PLyString_FromJsonbValue(JsonbValue *jbv)
      74             : {
      75             :     Assert(jbv->type == jbvString);
      76             : 
      77          42 :     return PyString_FromStringAndSize(jbv->val.string.val, jbv->val.string.len);
      78             : }
      79             : 
      80             : /*
      81             :  * PLyString_ToJsonbValue
      82             :  *
      83             :  * Transform Python string to JsonbValue.
      84             :  */
      85             : static void
      86          26 : PLyString_ToJsonbValue(PyObject *obj, JsonbValue *jbvElem)
      87             : {
      88          26 :     jbvElem->type = jbvString;
      89          26 :     jbvElem->val.string.val = PLyObject_AsString(obj);
      90          26 :     jbvElem->val.string.len = strlen(jbvElem->val.string.val);
      91          26 : }
      92             : 
      93             : /*
      94             :  * PLyObject_FromJsonbValue
      95             :  *
      96             :  * Transform JsonbValue to PyObject.
      97             :  */
      98             : static PyObject *
      99          80 : PLyObject_FromJsonbValue(JsonbValue *jsonbValue)
     100             : {
     101          80 :     switch (jsonbValue->type)
     102             :     {
     103             :         case jbvNull:
     104          10 :             Py_RETURN_NONE;
     105             : 
     106             :         case jbvBinary:
     107           8 :             return PLyObject_FromJsonbContainer(jsonbValue->val.binary.data);
     108             : 
     109             :         case jbvNumeric:
     110             :             {
     111             :                 Datum       num;
     112             :                 char       *str;
     113             : 
     114          36 :                 num = NumericGetDatum(jsonbValue->val.numeric);
     115          36 :                 str = DatumGetCString(DirectFunctionCall1(numeric_out, num));
     116             : 
     117          36 :                 return PyObject_CallFunction(decimal_constructor, "s", str);
     118             :             }
     119             : 
     120             :         case jbvString:
     121          16 :             return PLyString_FromJsonbValue(jsonbValue);
     122             : 
     123             :         case jbvBool:
     124          10 :             if (jsonbValue->val.boolean)
     125          10 :                 Py_RETURN_TRUE;
     126             :             else
     127           0 :                 Py_RETURN_FALSE;
     128             : 
     129             :         default:
     130           0 :             elog(ERROR, "unexpected jsonb value type: %d", jsonbValue->type);
     131             :             return NULL;
     132             :     }
     133             : }
     134             : 
     135             : /*
     136             :  * PLyObject_FromJsonb
     137             :  *
     138             :  * Transform JsonbContainer to PyObject.
     139             :  */
     140             : static PyObject *
     141          60 : PLyObject_FromJsonbContainer(JsonbContainer *jsonb)
     142             : {
     143             :     JsonbIteratorToken r;
     144             :     JsonbValue  v;
     145             :     JsonbIterator *it;
     146             :     PyObject   *result;
     147             : 
     148          60 :     it = JsonbIteratorInit(jsonb);
     149          60 :     r = JsonbIteratorNext(&it, &v, true);
     150             : 
     151          60 :     switch (r)
     152             :     {
     153             :         case WJB_BEGIN_ARRAY:
     154          40 :             if (v.val.array.rawScalar)
     155             :             {
     156             :                 JsonbValue  tmp;
     157             : 
     158          18 :                 if ((r = JsonbIteratorNext(&it, &v, true)) != WJB_ELEM ||
     159          18 :                     (r = JsonbIteratorNext(&it, &tmp, true)) != WJB_END_ARRAY ||
     160             :                     (r = JsonbIteratorNext(&it, &tmp, true)) != WJB_DONE)
     161           0 :                     elog(ERROR, "unexpected jsonb token: %d", r);
     162             : 
     163          18 :                 result = PLyObject_FromJsonbValue(&v);
     164             :             }
     165             :             else
     166             :             {
     167             :                 /* array in v */
     168          22 :                 result = PyList_New(0);
     169          22 :                 if (!result)
     170           0 :                     return NULL;
     171             : 
     172         102 :                 while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
     173             :                 {
     174          58 :                     if (r == WJB_ELEM)
     175             :                     {
     176          36 :                         PyObject   *elem = PLyObject_FromJsonbValue(&v);
     177             : 
     178          36 :                         PyList_Append(result, elem);
     179          36 :                         Py_XDECREF(elem);
     180             :                     }
     181             :                 }
     182             :             }
     183          40 :             break;
     184             : 
     185             :         case WJB_BEGIN_OBJECT:
     186          20 :             result = PyDict_New();
     187          20 :             if (!result)
     188           0 :                 return NULL;
     189             : 
     190          86 :             while ((r = JsonbIteratorNext(&it, &v, true)) != WJB_DONE)
     191             :             {
     192          46 :                 if (r == WJB_KEY)
     193             :                 {
     194          26 :                     PyObject   *key = PLyString_FromJsonbValue(&v);
     195             : 
     196          26 :                     if (!key)
     197           0 :                         return NULL;
     198             : 
     199          26 :                     r = JsonbIteratorNext(&it, &v, true);
     200             : 
     201          26 :                     if (r == WJB_VALUE)
     202             :                     {
     203          26 :                         PyObject   *value = PLyObject_FromJsonbValue(&v);
     204             : 
     205          26 :                         if (!value)
     206             :                         {
     207           0 :                             Py_XDECREF(key);
     208           0 :                             return NULL;
     209             :                         }
     210             : 
     211          26 :                         PyDict_SetItem(result, key, value);
     212          26 :                         Py_XDECREF(value);
     213             :                     }
     214             : 
     215          26 :                     Py_XDECREF(key);
     216             :                 }
     217             :             }
     218          20 :             break;
     219             : 
     220             :         default:
     221           0 :             elog(ERROR, "unexpected jsonb token: %d", r);
     222             :             return NULL;
     223             :     }
     224             : 
     225          60 :     return result;
     226             : }
     227             : 
     228             : /*
     229             :  * PLyMapping_ToJsonbValue
     230             :  *
     231             :  * Transform Python dict to JsonbValue.
     232             :  */
     233             : static JsonbValue *
     234          10 : PLyMapping_ToJsonbValue(PyObject *obj, JsonbParseState **jsonb_state)
     235             : {
     236             :     Py_ssize_t  pcount;
     237          10 :     JsonbValue *out = NULL;
     238             : 
     239             :     /* We need it volatile, since we use it after longjmp */
     240          10 :     volatile PyObject *items_v = NULL;
     241             : 
     242          10 :     pcount = PyMapping_Size(obj);
     243          10 :     items_v = PyMapping_Items(obj);
     244             : 
     245          10 :     PG_TRY();
     246             :     {
     247             :         Py_ssize_t  i;
     248             :         PyObject   *items;
     249             : 
     250          10 :         items = (PyObject *) items_v;
     251             : 
     252          10 :         pushJsonbValue(jsonb_state, WJB_BEGIN_OBJECT, NULL);
     253             : 
     254          24 :         for (i = 0; i < pcount; i++)
     255             :         {
     256             :             JsonbValue  jbvKey;
     257          14 :             PyObject   *item = PyList_GetItem(items, i);
     258          14 :             PyObject   *key = PyTuple_GetItem(item, 0);
     259          14 :             PyObject   *value = PyTuple_GetItem(item, 1);
     260             : 
     261             :             /* Python dictionary can have None as key */
     262          14 :             if (key == Py_None)
     263             :             {
     264           2 :                 jbvKey.type = jbvString;
     265           2 :                 jbvKey.val.string.len = 0;
     266           2 :                 jbvKey.val.string.val = "";
     267             :             }
     268             :             else
     269             :             {
     270             :                 /* All others types of keys we serialize to string */
     271          12 :                 PLyString_ToJsonbValue(key, &jbvKey);
     272             :             }
     273             : 
     274          14 :             (void) pushJsonbValue(jsonb_state, WJB_KEY, &jbvKey);
     275          14 :             (void) PLyObject_ToJsonbValue(value, jsonb_state, false);
     276             :         }
     277             : 
     278          10 :         out = pushJsonbValue(jsonb_state, WJB_END_OBJECT, NULL);
     279             :     }
     280           0 :     PG_CATCH();
     281             :     {
     282           0 :         Py_DECREF(items_v);
     283           0 :         PG_RE_THROW();
     284             :     }
     285          10 :     PG_END_TRY();
     286             : 
     287          10 :     return out;
     288             : }
     289             : 
     290             : /*
     291             :  * PLySequence_ToJsonbValue
     292             :  *
     293             :  * Transform python list to JsonbValue. Expects transformed PyObject and
     294             :  * a state required for jsonb construction.
     295             :  */
     296             : static JsonbValue *
     297          20 : PLySequence_ToJsonbValue(PyObject *obj, JsonbParseState **jsonb_state)
     298             : {
     299             :     Py_ssize_t  i;
     300             :     Py_ssize_t  pcount;
     301             : 
     302          20 :     pcount = PySequence_Size(obj);
     303             : 
     304          20 :     pushJsonbValue(jsonb_state, WJB_BEGIN_ARRAY, NULL);
     305             : 
     306          56 :     for (i = 0; i < pcount; i++)
     307             :     {
     308          36 :         PyObject   *value = PySequence_GetItem(obj, i);
     309             : 
     310          36 :         (void) PLyObject_ToJsonbValue(value, jsonb_state, true);
     311             : 
     312          36 :         Py_XDECREF(value);
     313             :     }
     314             : 
     315          20 :     return pushJsonbValue(jsonb_state, WJB_END_ARRAY, NULL);
     316             : }
     317             : 
     318             : /*
     319             :  * PLyNumber_ToJsonbValue(PyObject *obj)
     320             :  *
     321             :  * Transform python number to JsonbValue.
     322             :  */
     323             : static JsonbValue *
     324          32 : PLyNumber_ToJsonbValue(PyObject *obj, JsonbValue *jbvNum)
     325             : {
     326             :     Numeric     num;
     327          32 :     char       *str = PLyObject_AsString(obj);
     328             : 
     329          32 :     PG_TRY();
     330             :     {
     331             :         Datum       numd;
     332             : 
     333          32 :         numd = DirectFunctionCall3(numeric_in,
     334             :                                    CStringGetDatum(str),
     335             :                                    ObjectIdGetDatum(InvalidOid),
     336             :                                    Int32GetDatum(-1));
     337          30 :         num = DatumGetNumeric(numd);
     338             :     }
     339           2 :     PG_CATCH();
     340             :     {
     341           2 :         ereport(ERROR,
     342             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
     343             :                  (errmsg("could not convert value \"%s\" to jsonb", str))));
     344             :     }
     345          30 :     PG_END_TRY();
     346             : 
     347          30 :     pfree(str);
     348             : 
     349             :     /*
     350             :      * jsonb doesn't allow NaN (per JSON specification), so we have to prevent
     351             :      * it here explicitly.  (Infinity is also not allowed in jsonb, but
     352             :      * numeric_in above already catches that.)
     353             :      */
     354          30 :     if (numeric_is_nan(num))
     355           0 :         ereport(ERROR,
     356             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     357             :                  (errmsg("cannot convert NaN to jsonb"))));
     358             : 
     359          30 :     jbvNum->type = jbvNumeric;
     360          30 :     jbvNum->val.numeric = num;
     361             : 
     362          30 :     return jbvNum;
     363             : }
     364             : 
     365             : /*
     366             :  * PLyObject_ToJsonbValue(PyObject *obj)
     367             :  *
     368             :  * Transform python object to JsonbValue.
     369             :  */
     370             : static JsonbValue *
     371          94 : PLyObject_ToJsonbValue(PyObject *obj, JsonbParseState **jsonb_state, bool is_elem)
     372             : {
     373             :     JsonbValue  buf;
     374             :     JsonbValue *out;
     375             : 
     376          94 :     if (!(PyString_Check(obj) || PyUnicode_Check(obj)))
     377             :     {
     378          80 :         if (PySequence_Check(obj))
     379          20 :             return PLySequence_ToJsonbValue(obj, jsonb_state);
     380          60 :         else if (PyMapping_Check(obj))
     381          10 :             return PLyMapping_ToJsonbValue(obj, jsonb_state);
     382             :     }
     383             : 
     384             :     /* Allocate JsonbValue in heap only if it is raw scalar value. */
     385          64 :     if (*jsonb_state)
     386          50 :         out = &buf;
     387             :     else
     388          14 :         out = palloc(sizeof(JsonbValue));
     389             : 
     390          64 :     if (obj == Py_None)
     391           8 :         out->type = jbvNull;
     392          56 :     else if (PyString_Check(obj) || PyUnicode_Check(obj))
     393          14 :         PLyString_ToJsonbValue(obj, out);
     394             : 
     395             :     /*
     396             :      * PyNumber_Check() returns true for booleans, so boolean check should
     397             :      * come first.
     398             :      */
     399          42 :     else if (PyBool_Check(obj))
     400             :     {
     401          10 :         out->type = jbvBool;
     402          10 :         out->val.boolean = (obj == Py_True);
     403             :     }
     404          32 :     else if (PyNumber_Check(obj))
     405          32 :         out = PLyNumber_ToJsonbValue(obj, out);
     406             :     else
     407           0 :         ereport(ERROR,
     408             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     409             :                  (errmsg("Python type \"%s\" cannot be transformed to jsonb",
     410             :                          PLyObject_AsString((PyObject *) obj->ob_type)))));
     411             : 
     412             :     /* Push result into 'jsonb_state' unless it is raw scalar value. */
     413          62 :     return (*jsonb_state ?
     414          62 :             pushJsonbValue(jsonb_state, is_elem ? WJB_ELEM : WJB_VALUE, out) :
     415             :             out);
     416             : }
     417             : 
     418             : /*
     419             :  * plpython_to_jsonb
     420             :  *
     421             :  * Transform python object to Jsonb datum
     422             :  */
     423           6 : PG_FUNCTION_INFO_V1(plpython_to_jsonb);
     424             : Datum
     425          44 : plpython_to_jsonb(PG_FUNCTION_ARGS)
     426             : {
     427             :     PyObject   *obj;
     428             :     JsonbValue *out;
     429          44 :     JsonbParseState *jsonb_state = NULL;
     430             : 
     431          44 :     obj = (PyObject *) PG_GETARG_POINTER(0);
     432          44 :     out = PLyObject_ToJsonbValue(obj, &jsonb_state, true);
     433          42 :     PG_RETURN_POINTER(JsonbValueToJsonb(out));
     434             : }
     435             : 
     436             : /*
     437             :  * jsonb_to_plpython
     438             :  *
     439             :  * Transform Jsonb datum to PyObject and return it as internal.
     440             :  */
     441           8 : PG_FUNCTION_INFO_V1(jsonb_to_plpython);
     442             : Datum
     443          52 : jsonb_to_plpython(PG_FUNCTION_ARGS)
     444             : {
     445             :     PyObject   *result;
     446          52 :     Jsonb      *in = PG_GETARG_JSONB_P(0);
     447             : 
     448             :     /*
     449             :      * Initialize pointer to Decimal constructor. First we try "cdecimal", C
     450             :      * version of decimal library. In case of failure we use slower "decimal"
     451             :      * module.
     452             :      */
     453          52 :     if (!decimal_constructor)
     454             :     {
     455           2 :         PyObject   *decimal_module = PyImport_ImportModule("cdecimal");
     456             : 
     457           2 :         if (!decimal_module)
     458             :         {
     459           2 :             PyErr_Clear();
     460           2 :             decimal_module = PyImport_ImportModule("decimal");
     461             :         }
     462             :         Assert(decimal_module);
     463           2 :         decimal_constructor = PyObject_GetAttrString(decimal_module, "Decimal");
     464             :     }
     465             : 
     466          52 :     result = PLyObject_FromJsonbContainer(&in->root);
     467          52 :     if (!result)
     468           0 :         PLy_elog(ERROR, "transformation from jsonb to Python failed");
     469             : 
     470          52 :     return PointerGetDatum(result);
     471             : }

Generated by: LCOV version 1.13