LCOV - code coverage report
Current view: top level - contrib/jsonb_plpython - jsonb_plpython.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12devel Lines: 135 150 90.0 %
Date: 2019-03-25 12:21:07 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 :     PyObject *volatile items = NULL;
     241             : 
     242          10 :     pcount = PyMapping_Size(obj);
     243          10 :     items = PyMapping_Items(obj);
     244             : 
     245          10 :     PG_TRY();
     246             :     {
     247             :         Py_ssize_t  i;
     248             : 
     249          10 :         pushJsonbValue(jsonb_state, WJB_BEGIN_OBJECT, NULL);
     250             : 
     251          24 :         for (i = 0; i < pcount; i++)
     252             :         {
     253             :             JsonbValue  jbvKey;
     254          14 :             PyObject   *item = PyList_GetItem(items, i);
     255          14 :             PyObject   *key = PyTuple_GetItem(item, 0);
     256          14 :             PyObject   *value = PyTuple_GetItem(item, 1);
     257             : 
     258             :             /* Python dictionary can have None as key */
     259          14 :             if (key == Py_None)
     260             :             {
     261           2 :                 jbvKey.type = jbvString;
     262           2 :                 jbvKey.val.string.len = 0;
     263           2 :                 jbvKey.val.string.val = "";
     264             :             }
     265             :             else
     266             :             {
     267             :                 /* All others types of keys we serialize to string */
     268          12 :                 PLyString_ToJsonbValue(key, &jbvKey);
     269             :             }
     270             : 
     271          14 :             (void) pushJsonbValue(jsonb_state, WJB_KEY, &jbvKey);
     272          14 :             (void) PLyObject_ToJsonbValue(value, jsonb_state, false);
     273             :         }
     274             : 
     275          10 :         out = pushJsonbValue(jsonb_state, WJB_END_OBJECT, NULL);
     276             :     }
     277           0 :     PG_CATCH();
     278             :     {
     279           0 :         Py_DECREF(items);
     280           0 :         PG_RE_THROW();
     281             :     }
     282          10 :     PG_END_TRY();
     283             : 
     284          10 :     return out;
     285             : }
     286             : 
     287             : /*
     288             :  * PLySequence_ToJsonbValue
     289             :  *
     290             :  * Transform python list to JsonbValue. Expects transformed PyObject and
     291             :  * a state required for jsonb construction.
     292             :  */
     293             : static JsonbValue *
     294          20 : PLySequence_ToJsonbValue(PyObject *obj, JsonbParseState **jsonb_state)
     295             : {
     296             :     Py_ssize_t  i;
     297             :     Py_ssize_t  pcount;
     298             : 
     299          20 :     pcount = PySequence_Size(obj);
     300             : 
     301          20 :     pushJsonbValue(jsonb_state, WJB_BEGIN_ARRAY, NULL);
     302             : 
     303          56 :     for (i = 0; i < pcount; i++)
     304             :     {
     305          36 :         PyObject   *value = PySequence_GetItem(obj, i);
     306             : 
     307          36 :         (void) PLyObject_ToJsonbValue(value, jsonb_state, true);
     308             : 
     309          36 :         Py_XDECREF(value);
     310             :     }
     311             : 
     312          20 :     return pushJsonbValue(jsonb_state, WJB_END_ARRAY, NULL);
     313             : }
     314             : 
     315             : /*
     316             :  * PLyNumber_ToJsonbValue(PyObject *obj)
     317             :  *
     318             :  * Transform python number to JsonbValue.
     319             :  */
     320             : static JsonbValue *
     321          32 : PLyNumber_ToJsonbValue(PyObject *obj, JsonbValue *jbvNum)
     322             : {
     323             :     Numeric     num;
     324          32 :     char       *str = PLyObject_AsString(obj);
     325             : 
     326          32 :     PG_TRY();
     327             :     {
     328             :         Datum       numd;
     329             : 
     330          32 :         numd = DirectFunctionCall3(numeric_in,
     331             :                                    CStringGetDatum(str),
     332             :                                    ObjectIdGetDatum(InvalidOid),
     333             :                                    Int32GetDatum(-1));
     334          30 :         num = DatumGetNumeric(numd);
     335             :     }
     336           2 :     PG_CATCH();
     337             :     {
     338           2 :         ereport(ERROR,
     339             :                 (errcode(ERRCODE_DATATYPE_MISMATCH),
     340             :                  (errmsg("could not convert value \"%s\" to jsonb", str))));
     341             :     }
     342          30 :     PG_END_TRY();
     343             : 
     344          30 :     pfree(str);
     345             : 
     346             :     /*
     347             :      * jsonb doesn't allow NaN (per JSON specification), so we have to prevent
     348             :      * it here explicitly.  (Infinity is also not allowed in jsonb, but
     349             :      * numeric_in above already catches that.)
     350             :      */
     351          30 :     if (numeric_is_nan(num))
     352           0 :         ereport(ERROR,
     353             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     354             :                  (errmsg("cannot convert NaN to jsonb"))));
     355             : 
     356          30 :     jbvNum->type = jbvNumeric;
     357          30 :     jbvNum->val.numeric = num;
     358             : 
     359          30 :     return jbvNum;
     360             : }
     361             : 
     362             : /*
     363             :  * PLyObject_ToJsonbValue(PyObject *obj)
     364             :  *
     365             :  * Transform python object to JsonbValue.
     366             :  */
     367             : static JsonbValue *
     368          94 : PLyObject_ToJsonbValue(PyObject *obj, JsonbParseState **jsonb_state, bool is_elem)
     369             : {
     370             :     JsonbValue  buf;
     371             :     JsonbValue *out;
     372             : 
     373          94 :     if (!(PyString_Check(obj) || PyUnicode_Check(obj)))
     374             :     {
     375          80 :         if (PySequence_Check(obj))
     376          20 :             return PLySequence_ToJsonbValue(obj, jsonb_state);
     377          60 :         else if (PyMapping_Check(obj))
     378          10 :             return PLyMapping_ToJsonbValue(obj, jsonb_state);
     379             :     }
     380             : 
     381             :     /* Allocate JsonbValue in heap only if it is raw scalar value. */
     382          64 :     if (*jsonb_state)
     383          50 :         out = &buf;
     384             :     else
     385          14 :         out = palloc(sizeof(JsonbValue));
     386             : 
     387          64 :     if (obj == Py_None)
     388           8 :         out->type = jbvNull;
     389          56 :     else if (PyString_Check(obj) || PyUnicode_Check(obj))
     390          14 :         PLyString_ToJsonbValue(obj, out);
     391             : 
     392             :     /*
     393             :      * PyNumber_Check() returns true for booleans, so boolean check should
     394             :      * come first.
     395             :      */
     396          42 :     else if (PyBool_Check(obj))
     397             :     {
     398          10 :         out->type = jbvBool;
     399          10 :         out->val.boolean = (obj == Py_True);
     400             :     }
     401          32 :     else if (PyNumber_Check(obj))
     402          32 :         out = PLyNumber_ToJsonbValue(obj, out);
     403             :     else
     404           0 :         ereport(ERROR,
     405             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     406             :                  (errmsg("Python type \"%s\" cannot be transformed to jsonb",
     407             :                          PLyObject_AsString((PyObject *) obj->ob_type)))));
     408             : 
     409             :     /* Push result into 'jsonb_state' unless it is raw scalar value. */
     410          62 :     return (*jsonb_state ?
     411          62 :             pushJsonbValue(jsonb_state, is_elem ? WJB_ELEM : WJB_VALUE, out) :
     412             :             out);
     413             : }
     414             : 
     415             : /*
     416             :  * plpython_to_jsonb
     417             :  *
     418             :  * Transform python object to Jsonb datum
     419             :  */
     420           6 : PG_FUNCTION_INFO_V1(plpython_to_jsonb);
     421             : Datum
     422          44 : plpython_to_jsonb(PG_FUNCTION_ARGS)
     423             : {
     424             :     PyObject   *obj;
     425             :     JsonbValue *out;
     426          44 :     JsonbParseState *jsonb_state = NULL;
     427             : 
     428          44 :     obj = (PyObject *) PG_GETARG_POINTER(0);
     429          44 :     out = PLyObject_ToJsonbValue(obj, &jsonb_state, true);
     430          42 :     PG_RETURN_POINTER(JsonbValueToJsonb(out));
     431             : }
     432             : 
     433             : /*
     434             :  * jsonb_to_plpython
     435             :  *
     436             :  * Transform Jsonb datum to PyObject and return it as internal.
     437             :  */
     438           8 : PG_FUNCTION_INFO_V1(jsonb_to_plpython);
     439             : Datum
     440          52 : jsonb_to_plpython(PG_FUNCTION_ARGS)
     441             : {
     442             :     PyObject   *result;
     443          52 :     Jsonb      *in = PG_GETARG_JSONB_P(0);
     444             : 
     445             :     /*
     446             :      * Initialize pointer to Decimal constructor. First we try "cdecimal", C
     447             :      * version of decimal library. In case of failure we use slower "decimal"
     448             :      * module.
     449             :      */
     450          52 :     if (!decimal_constructor)
     451             :     {
     452           2 :         PyObject   *decimal_module = PyImport_ImportModule("cdecimal");
     453             : 
     454           2 :         if (!decimal_module)
     455             :         {
     456           2 :             PyErr_Clear();
     457           2 :             decimal_module = PyImport_ImportModule("decimal");
     458             :         }
     459             :         Assert(decimal_module);
     460           2 :         decimal_constructor = PyObject_GetAttrString(decimal_module, "Decimal");
     461             :     }
     462             : 
     463          52 :     result = PLyObject_FromJsonbContainer(&in->root);
     464          52 :     if (!result)
     465           0 :         PLy_elog(ERROR, "transformation from jsonb to Python failed");
     466             : 
     467          52 :     return PointerGetDatum(result);
     468             : }

Generated by: LCOV version 1.13