hstore_plpython.c File Reference

#include "postgres.h"
#include "fmgr.h"
#include "hstore/hstore.h"
#include "plpy_typeio.h"
#include "plpython.h"

Include dependency graph for hstore_plpython.c:

Go to the source code of this file.

Macros
#define	PLyObject_AsString   PLyObject_AsString_p
#define	PLyUnicode_FromStringAndSize   PLyUnicode_FromStringAndSize_p
#define	hstoreUpgrade   hstoreUpgrade_p
#define	hstoreUniquePairs   hstoreUniquePairs_p
#define	hstorePairs   hstorePairs_p
#define	hstoreCheckKeyLen   hstoreCheckKeyLen_p
#define	hstoreCheckValLen   hstoreCheckValLen_p

Typedefs
typedef char *(*	PLyObject_AsString_t) (PyObject *plrv)
typedef PyObject *(*	PLyUnicode_FromStringAndSize_t) (const char *s, Py_ssize_t size)
typedef HStore *(*	hstoreUpgrade_t) (Datum orig)
typedef int(*	hstoreUniquePairs_t) (Pairs *a, int32 l, int32 *buflen)
typedef HStore *(*	hstorePairs_t) (Pairs *pairs, int32 pcount, int32 buflen)
typedef size_t(*	hstoreCheckKeyLen_t) (size_t len)
typedef size_t(*	hstoreCheckValLen_t) (size_t len)

Functions
void	_PG_init (void)
	PG_FUNCTION_INFO_V1 (hstore_to_plpython)
Datum	hstore_to_plpython (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (plpython_to_hstore)
Datum	plpython_to_hstore (PG_FUNCTION_ARGS)

Variables
	PG_MODULE_MAGIC
static PLyObject_AsString_t	PLyObject_AsString_p
static PLyUnicode_FromStringAndSize_t	PLyUnicode_FromStringAndSize_p
static hstoreUpgrade_t	hstoreUpgrade_p
static hstoreUniquePairs_t	hstoreUniquePairs_p
static hstorePairs_t	hstorePairs_p
static hstoreCheckKeyLen_t	hstoreCheckKeyLen_p
static hstoreCheckValLen_t	hstoreCheckValLen_p

Macro Definition Documentation

hstoreCheckKeyLen

#define hstoreCheckKeyLen   hstoreCheckKeyLen_p

Definition at line 73 of file hstore_plpython.c.

hstoreCheckValLen

#define hstoreCheckValLen   hstoreCheckValLen_p

Definition at line 74 of file hstore_plpython.c.

hstorePairs

#define hstorePairs   hstorePairs_p

Definition at line 72 of file hstore_plpython.c.

hstoreUniquePairs

#define hstoreUniquePairs   hstoreUniquePairs_p

Definition at line 71 of file hstore_plpython.c.

hstoreUpgrade

#define hstoreUpgrade   hstoreUpgrade_p

Definition at line 70 of file hstore_plpython.c.

PLyObject_AsString

#define PLyObject_AsString   PLyObject_AsString_p

Definition at line 68 of file hstore_plpython.c.

PLyUnicode_FromStringAndSize

#define PLyUnicode_FromStringAndSize   PLyUnicode_FromStringAndSize_p

Definition at line 69 of file hstore_plpython.c.

Typedef Documentation

hstoreCheckKeyLen_t

typedef size_t(* hstoreCheckKeyLen_t) (size_t len)

Definition at line 23 of file hstore_plpython.c.

hstoreCheckValLen_t

typedef size_t(* hstoreCheckValLen_t) (size_t len)

Definition at line 25 of file hstore_plpython.c.

hstorePairs_t

typedef HStore*(* hstorePairs_t) (Pairs *pairs, int32 pcount, int32 buflen)

Definition at line 21 of file hstore_plpython.c.

hstoreUniquePairs_t

typedef int(* hstoreUniquePairs_t) (Pairs *a, int32 l, int32 *buflen)

Definition at line 19 of file hstore_plpython.c.

hstoreUpgrade_t

typedef HStore*(* hstoreUpgrade_t) (Datum orig)

Definition at line 17 of file hstore_plpython.c.

PLyObject_AsString_t

typedef char*(* PLyObject_AsString_t) (PyObject *plrv)

Definition at line 11 of file hstore_plpython.c.

PLyUnicode_FromStringAndSize_t

typedef PyObject*(* PLyUnicode_FromStringAndSize_t) (const char *s, Py_ssize_t size)

Definition at line 13 of file hstore_plpython.c.

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 33 of file hstore_plpython.c.

{
    /* Asserts verify that typedefs above match original declarations */
    AssertVariableIsOfType(&PLyObject_AsString, PLyObject_AsString_t);
    PLyObject_AsString_p = (PLyObject_AsString_t)
        load_external_function("$libdir/" PLPYTHON_LIBNAME, "PLyObject_AsString",
                               true, NULL);
    AssertVariableIsOfType(&PLyUnicode_FromStringAndSize, PLyUnicode_FromStringAndSize_t);
    PLyUnicode_FromStringAndSize_p = (PLyUnicode_FromStringAndSize_t)
        load_external_function("$libdir/" PLPYTHON_LIBNAME, "PLyUnicode_FromStringAndSize",
                               true, NULL);
    AssertVariableIsOfType(&hstoreUpgrade, hstoreUpgrade_t);
    hstoreUpgrade_p = (hstoreUpgrade_t)
        load_external_function("$libdir/hstore", "hstoreUpgrade",
                               true, NULL);
    AssertVariableIsOfType(&hstoreUniquePairs, hstoreUniquePairs_t);
    hstoreUniquePairs_p = (hstoreUniquePairs_t)
        load_external_function("$libdir/hstore", "hstoreUniquePairs",
                               true, NULL);
    AssertVariableIsOfType(&hstorePairs, hstorePairs_t);
    hstorePairs_p = (hstorePairs_t)
        load_external_function("$libdir/hstore", "hstorePairs",
                               true, NULL);
    AssertVariableIsOfType(&hstoreCheckKeyLen, hstoreCheckKeyLen_t);
    hstoreCheckKeyLen_p = (hstoreCheckKeyLen_t)
        load_external_function("$libdir/hstore", "hstoreCheckKeyLen",
                               true, NULL);
    AssertVariableIsOfType(&hstoreCheckValLen, hstoreCheckValLen_t);
    hstoreCheckValLen_p = (hstoreCheckValLen_t)
        load_external_function("$libdir/hstore", "hstoreCheckValLen",
                               true, NULL);
}

References AssertVariableIsOfType, hstoreCheckKeyLen, hstoreCheckKeyLen_p, hstoreCheckValLen, hstoreCheckValLen_p, hstorePairs, hstorePairs_p, hstoreUniquePairs, hstoreUniquePairs_p, hstoreUpgrade, hstoreUpgrade_p, load_external_function(), PLyObject_AsString, PLyObject_AsString_p, PLyUnicode_FromStringAndSize, and PLyUnicode_FromStringAndSize_p.

hstore_to_plpython()

Datum hstore_to_plpython

(

PG_FUNCTION_ARGS

)

Definition at line 80 of file hstore_plpython.c.

{
    HStore     *in = PG_GETARG_HSTORE_P(0);
    int         i;
    int         count = HS_COUNT(in);
    char       *base = STRPTR(in);
    HEntry     *entries = ARRPTR(in);
    PyObject   *dict;
 
    dict = PyDict_New();
    if (!dict)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory")));
 
    for (i = 0; i < count; i++)
    {
        PyObject   *key;
 
        key = PLyUnicode_FromStringAndSize(HSTORE_KEY(entries, base, i),
                                           HSTORE_KEYLEN(entries, i));
        if (HSTORE_VALISNULL(entries, i))
            PyDict_SetItem(dict, key, Py_None);
        else
        {
            PyObject   *value;
 
            value = PLyUnicode_FromStringAndSize(HSTORE_VAL(entries, base, i),
                                                 HSTORE_VALLEN(entries, i));
            PyDict_SetItem(dict, key, value);
            Py_XDECREF(value);
        }
        Py_XDECREF(key);
    }
 
    return PointerGetDatum(dict);
}

References ARRPTR, ereport, errcode(), errmsg(), ERROR, HS_COUNT, HSTORE_KEY, HSTORE_KEYLEN, HSTORE_VAL, HSTORE_VALISNULL, HSTORE_VALLEN, i, sort-test::key, PG_GETARG_HSTORE_P, PLyUnicode_FromStringAndSize, PointerGetDatum(), STRPTR, and value.

PG_FUNCTION_INFO_V1() [1/2]

PG_FUNCTION_INFO_V1

(

hstore_to_plpython

)

PG_FUNCTION_INFO_V1() [2/2]

PG_FUNCTION_INFO_V1

(

plpython_to_hstore

)

plpython_to_hstore()

Datum plpython_to_hstore

(

PG_FUNCTION_ARGS

)

Definition at line 122 of file hstore_plpython.c.

{
    PyObject   *dict;
    PyObject   *volatile items;
    Py_ssize_t  pcount;
    HStore     *volatile out;
 
    dict = (PyObject *) PG_GETARG_POINTER(0);
 
    /*
     * As of Python 3, PyMapping_Check() is unreliable unless one first checks
     * that the object isn't a sequence.  (Cleaner solutions exist, but not
     * before Python 3.10, which we're not prepared to require yet.)
     */
    if (PySequence_Check(dict) || !PyMapping_Check(dict))
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("not a Python mapping")));
 
    pcount = PyMapping_Size(dict);
    items = PyMapping_Items(dict);
 
    PG_TRY();
    {
        int32       buflen;
        Py_ssize_t  i;
        Pairs      *pairs;
 
        pairs = palloc(pcount * sizeof(*pairs));
 
        for (i = 0; i < pcount; i++)
        {
            PyObject   *tuple;
            PyObject   *key;
            PyObject   *value;
 
            tuple = PyList_GetItem(items, i);
            key = PyTuple_GetItem(tuple, 0);
            value = PyTuple_GetItem(tuple, 1);
 
            pairs[i].key = PLyObject_AsString(key);
            pairs[i].keylen = hstoreCheckKeyLen(strlen(pairs[i].key));
            pairs[i].needfree = true;
 
            if (value == Py_None)
            {
                pairs[i].val = NULL;
                pairs[i].vallen = 0;
                pairs[i].isnull = true;
            }
            else
            {
                pairs[i].val = PLyObject_AsString(value);
                pairs[i].vallen = hstoreCheckValLen(strlen(pairs[i].val));
                pairs[i].isnull = false;
            }
        }
 
        pcount = hstoreUniquePairs(pairs, pcount, &buflen);
        out = hstorePairs(pairs, pcount, buflen);
    }
    PG_FINALLY();
    {
        Py_DECREF(items);
    }
    PG_END_TRY();
 
    PG_RETURN_POINTER(out);
}

References ereport, errcode(), errmsg(), ERROR, hstoreCheckKeyLen, hstoreCheckValLen, hstorePairs, hstoreUniquePairs, i, Pairs::isnull, Pairs::key, sort-test::key, Pairs::keylen, Pairs::needfree, palloc(), PG_END_TRY, PG_FINALLY, PG_GETARG_POINTER, PG_RETURN_POINTER, PG_TRY, PLyObject_AsString, Pairs::val, val, Pairs::vallen, and value.

Variable Documentation

hstoreCheckKeyLen_p

hstoreCheckKeyLen_t hstoreCheckKeyLen_p

static

Definition at line 24 of file hstore_plpython.c.

Referenced by _PG_init().

hstoreCheckValLen_p

hstoreCheckValLen_t hstoreCheckValLen_p

static

Definition at line 26 of file hstore_plpython.c.

Referenced by _PG_init().

hstorePairs_p

hstorePairs_t hstorePairs_p

static

Definition at line 22 of file hstore_plpython.c.

Referenced by _PG_init().

hstoreUniquePairs_p

hstoreUniquePairs_t hstoreUniquePairs_p

static

Definition at line 20 of file hstore_plpython.c.

Referenced by _PG_init().

hstoreUpgrade_p

hstoreUpgrade_t hstoreUpgrade_p

static

Definition at line 18 of file hstore_plpython.c.

Referenced by _PG_init().

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 8 of file hstore_plpython.c.

PLyObject_AsString_p

PLyObject_AsString_t PLyObject_AsString_p

static

Definition at line 12 of file hstore_plpython.c.

Referenced by _PG_init().

PLyUnicode_FromStringAndSize_p

PLyUnicode_FromStringAndSize_t PLyUnicode_FromStringAndSize_p

static

Definition at line 14 of file hstore_plpython.c.

Referenced by _PG_init().