pgestraier/trunk/pgest.c

/*
 * integrate Hyper Estraier into PostgreSQL
 *
 * Dobrica Pavlinusic <dpavlin@rot13.org> 2005-05-19
 *
 * TODO:
 * - all
 *
 * NOTES:
 * - clear structures with memset to support hash indexes (who whould like
 *   to create hash index on table returned from function?)
 * - number of returned rows is set by PostgreSQL evaluator, see:
 *   http://archives.postgresql.org/pgsql-hackers/2005-02/msg00546.php
 *
 * Based on:
 * - C example from PostgreSQL documentation (BSD licence)
 * - coreexample002.c and nodeexample002.c from Hyper Estraier (GPL)
 * - _textin/_textout from pgcurl.c (LGPL)
 *
 * This code is licenced under GPL
 */

#include "postgres.h"
#include "fmgr.h"
#include "funcapi.h"
#include "utils/builtins.h"
#include "utils/array.h"
#include "utils/lsyscache.h"
#include "miscadmin.h"
#include "commands/trigger.h"
#include "executor/spi.h"

#include <estraier.h>
#include <cabin.h>
#include <estnode.h>

#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
#define _textout(str) DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(str)))
#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))

/* SortMem got renamed in PostgreSQL 8.0 */
#ifndef SortMem
 #define SortMem 16 * 1024
#endif

#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif

#define ATTR_DELIMITER "{{!}}"
#define HINTS_PREFIX "HINTS."

/* prototype */
char *attr2text(ESTDOC *doc, char *attr);
char *node_attr2text(ESTRESDOC *rdoc, char *attr);
void cond_add_attr(ESTCOND *cond, char *attr);


/* work in progress */
PG_FUNCTION_INFO_V1(pgest_attr);
Datum pgest_attr(PG_FUNCTION_ARGS)
{
        ArrayType       *attr_arr = PG_GETARG_ARRAYTYPE_P(6);
        Oid             attr_element_type = ARR_ELEMTYPE(attr_arr);
        int             attr_ndims = ARR_NDIM(attr_arr);
        int             *attr_dim_counts = ARR_DIMS(attr_arr);
        int             *attr_dim_lower_bounds = ARR_LBOUND(attr_arr);
        int             ncols = 0;
        int             nrows = 0;
        int             indx[MAXDIM];
        int16           attr_len;
        bool            attr_byval;
        char            attr_align;
        ReturnSetInfo   *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
        AttInMetadata   *attinmeta;
        TupleDesc       tupdesc;
        Tuplestorestate *tupstore = NULL;
        HeapTuple       tuple;
        MemoryContext   per_query_ctx;
        MemoryContext   oldcontext;
        Datum           dvalue;
        char            **values;
        int             rsinfo_ncols;
        int             i, j;
        /* estvars */
        ESTDB *db;
        ESTCOND *cond;
        ESTDOC *doc;
        int ecode, *est_result, resnum;
        int limit = 0;
        int offset = 0;

        char            *index_path;
        char            *query;
        char            *attr;
        char            *order;


        /* only allow 1D input array */
        if (attr_ndims == 1)
        {
                ncols = attr_dim_counts[0];
        }
        else
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("invalid input array"),
                                 errdetail("Input array must have 1 dimension")));
                
        /* check to see if caller supports us returning a tuplestore */
        if (!rsinfo || !(rsinfo->allowedModes & SFRM_Materialize))
                ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("materialize mode required, but it is not " \
                                                "allowed in this context")));

        /* get info about element type needed to construct the array */
        get_typlenbyvalalign(attr_element_type, &attr_len, &attr_byval, &attr_align);

        /* get the requested return tuple description */
        tupdesc = rsinfo->expectedDesc;
        rsinfo_ncols = tupdesc->natts;

        /*
         * The requested tuple description better match up with the array
         * we were given.
         */
        if (rsinfo_ncols != ncols)
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("invalid input array"),
                                 errdetail("Number of elements in array must match number of query specified columns.")));

        /* OK, use it */
        attinmeta = TupleDescGetAttInMetadata(tupdesc);

        /* Now go to work */
        rsinfo->returnMode = SFRM_Materialize;

        per_query_ctx = fcinfo->flinfo->fn_mcxt;
        oldcontext = MemoryContextSwitchTo(per_query_ctx);

        /* initialize our tuplestore */
        tupstore = tuplestore_begin_heap(true, false, SortMem);


        /* take rest of arguments from function */

        /* index path */
        if (PG_ARGISNULL(0)) {
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("index path can't be null"),
                                 errdetail("Index path must be valid full path to HyperEstraier index")));
        }
        index_path = _textout(PG_GETARG_TEXT_P(0));

        /* query string */
        if (PG_ARGISNULL(1)) {
                query = "";
        } else {
                query = _textout(PG_GETARG_TEXT_P(1));
        }

        /* atribute filter */
        if (PG_ARGISNULL(2)) {
                attr = "";
        } else {
                attr = _textout(PG_GETARG_TEXT_P(2));
        }
        
        /* sort order */
        if (PG_ARGISNULL(3)) {
                order = "";
        } else {
                order = _textout(PG_GETARG_TEXT_P(3));
        }


        /* limit */
        if (PG_ARGISNULL(4)) {
                limit = 0;
        } else {
                limit = PG_GETARG_INT32(4);
        }

        /* offset */
        if (PG_ARGISNULL(5)) {
                offset = 0;
        } else {
                offset = PG_GETARG_INT32(5);
        }


        /* open the database */
        elog(DEBUG1, "pgest_attr: est_db_open(%s)", index_path);
                
        if(!(db = est_db_open(index_path, ESTDBREADER, &ecode))){
                ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                        errmsg("est_db_open: can't open %s: %d", index_path, ecode),
                        errdetail(est_err_msg(ecode))));
        }
                
        elog(DEBUG1, "pgest_attr: query[%s] attr[%s] limit %d offset %d", query, (PG_ARGISNULL(2) ? "NULL" : attr), limit, offset);
        
        /* create a search condition object */
        if (!(cond = est_cond_new())) {
                ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED),
                        errmsg("pgest_attr: est_cond_new failed")));
        }
        
        /* set the search phrase to the search condition object */
        if (! PG_ARGISNULL(1) && strlen(query) > 0)
                est_cond_set_phrase(cond, query);

        /* minimum valid attribute length is 10: @a STREQ a */
        if (! PG_ARGISNULL(2) && strlen(attr) >= 10) {
                elog(DEBUG1,"attributes: %s", attr);
                cond_add_attr(cond, attr);
        }

        /* set the search phrase to the search condition object */
        if (! PG_ARGISNULL(3) && strlen(order) > 0) {
                elog(DEBUG1,"est_cond_set_order(%s)", order);
                est_cond_set_order(cond, order);
        }

        if (limit) {
                elog(DEBUG1,"est_cond_set_max(%d)", limit + offset);
                est_cond_set_max(cond, limit + offset);
        }

        /* get the result of search */
        est_result = est_db_search(db, cond, &resnum, NULL);

        /* check if results exists */
        if ( 0 == resnum ) {
                elog(INFO, "pgest_attr: no results for: %s", query );
        }

        /* total number of tuples to be returned */
        if (limit && limit < resnum) {
                nrows = limit;
        } else {
                nrows = resnum - offset;
        }


        elog(DEBUG1, "pgest_attr: found %d hits for %s", resnum, query);

        values = (char **) palloc(ncols * sizeof(char *));

        for (i = 0; i < nrows; i++)
        {

                /* get result from estraier */
                if (! ( doc = est_db_get_doc(db, est_result[i + offset], 0)) ) {
                        elog(INFO, "pgest_attr: can't find result %d", i + offset);
                } else {
                        elog(DEBUG1, "URI: %s\n Title: %s\n",
                                est_doc_attr(doc, "@uri"),
                                est_doc_attr(doc, "@title")
                        );
                }

                /* iterate over results */
                for (j = 0; j < ncols; j++)
                {
                        bool    isnull;

                        /* array value of this position */
                        indx[0] = j + attr_dim_lower_bounds[0];

                        dvalue = array_ref(attr_arr, attr_ndims, indx, -1, attr_len, attr_byval, attr_align, &isnull);

                        if (!isnull && doc)
                                values[j] = DatumGetCString(
                                        attr2text(doc,
                                                (char *)DirectFunctionCall1(textout, dvalue)
                                        ));
                        else
                                values[j] = NULL;
                }
                /* construct the tuple */
                tuple = BuildTupleFromCStrings(attinmeta, values);

                /* now store it */
                tuplestore_puttuple(tupstore, tuple);

                /* delete estraier document object */
                if (doc) est_doc_delete(doc);
        }

        tuplestore_donestoring(tupstore);
        rsinfo->setResult = tupstore;

        /*
         * SFRM_Materialize mode expects us to return a NULL Datum. The actual
         * tuples are in our tuplestore and passed back through
         * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
         * that we actually used to build our tuples with, so the caller can
         * verify we did what it was expecting.
         */
        rsinfo->setDesc = tupdesc;
        MemoryContextSwitchTo(oldcontext);

        est_cond_delete(cond);

        if(!est_db_close(db, &ecode)){
                ereport(ERROR, (errcode(ERRCODE_IO_ERROR),
                        errmsg("est_db_close: %d", ecode),
                        errdetail(est_err_msg(ecode))));
        }

        return (Datum) 0;
}


/* make text var from attr */
char *attr2text(ESTDOC *doc, char *attr) {
        char *val;
        const char *attrval;
        int len;
        int attrlen;

        if (! doc) return (Datum) NULL;

        elog(DEBUG1, "doc: %p, attr: %s", doc, attr);

        if ( (attrval = est_doc_attr(doc, attr)) && (attrlen = strlen(attrval)) ) {
                val = (char *) palloc(attrlen * sizeof(char));
        } else {
                return (Datum) NULL;
        }

        len = strlen(attrval);
        elog(DEBUG1, "attr2text(%s) = '%s' %d bytes", attr, attrval, len);

        len++;
        len *= sizeof(char);

        elog(DEBUG2, "palloc(%d)", len);

        val = palloc(len);

        memset(val, 0, len);
        strncpy(val, attrval, len);

        elog(DEBUG2, "val=%s", val);

        return val;
}

/*
 * variation on theme: use node API which doesn't open index on
 * every query which is much faster for large indexes
 *
 */

/* select * from pgest( */
#define _arg_node_uri 0
#define _arg_login 1
#define _arg_passwd 2
#define _arg_depth 3
#define _arg_query 4
#define _arg_attr 5
#define _arg_order 6
#define _arg_limit 7
#define _arg_offset 8
#define _arg_attr_array 9
/* as (foo text, ... ); */


PG_FUNCTION_INFO_V1(pgest_node);
Datum pgest_node(PG_FUNCTION_ARGS)
{
        ArrayType       *attr_arr = PG_GETARG_ARRAYTYPE_P(_arg_attr_array);
        Oid             attr_element_type = ARR_ELEMTYPE(attr_arr);
        int             attr_ndims = ARR_NDIM(attr_arr);
        int             *attr_dim_counts = ARR_DIMS(attr_arr);
        int             *attr_dim_lower_bounds = ARR_LBOUND(attr_arr);
        int             ncols = 0;
        int             nrows = 0;
        int             indx[MAXDIM];
        int16           attr_len;
        bool            attr_byval;
        char            attr_align;
        ReturnSetInfo   *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
        AttInMetadata   *attinmeta;
        TupleDesc       tupdesc;
        Tuplestorestate *tupstore = NULL;
        HeapTuple       tuple;
        MemoryContext   per_query_ctx;
        MemoryContext   oldcontext;
        Datum           dvalue;
        char            **values;
        int             rsinfo_ncols;
        int             i, j;
        /* estvars */
        ESTNODE *node;
        ESTCOND *cond;
        ESTNODERES *nres;
        ESTRESDOC *rdoc;
        CBMAP *hints;
        int resnum = 0;
        int limit = 0;
        int offset = 0;
        int depth = 0;

        char            *node_url;
        char            *user, *passwd;
        char            *query;
        char            *attr;
        char            *order;


        /* only allow 1D input array */
        if (attr_ndims == 1)
        {
                ncols = attr_dim_counts[0];
        }
        else
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("invalid input array"),
                                 errdetail("Input array must have 1 dimension")));
                
        /* check to see if caller supports us returning a tuplestore */
        if (!rsinfo || !(rsinfo->allowedModes & SFRM_Materialize))
                ereport(ERROR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("materialize mode required, but it is not " \
                                                "allowed in this context")));

        /* get info about element type needed to construct the array */
        get_typlenbyvalalign(attr_element_type, &attr_len, &attr_byval, &attr_align);

        /* get the requested return tuple description */
        tupdesc = rsinfo->expectedDesc;
        rsinfo_ncols = tupdesc->natts;

        /*
         * The requested tuple description better match up with the array
         * we were given.
         */
        if (rsinfo_ncols != ncols)
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("invalid input array"),
                                 errdetail("Number of elements in array must match number of query specified columns.")));

        /* OK, use it */
        attinmeta = TupleDescGetAttInMetadata(tupdesc);

        /* Now go to work */
        rsinfo->returnMode = SFRM_Materialize;

        per_query_ctx = fcinfo->flinfo->fn_mcxt;
        oldcontext = MemoryContextSwitchTo(per_query_ctx);

        /* initialize our tuplestore */
        tupstore = tuplestore_begin_heap(true, false, SortMem);


        /* take rest of arguments from function */

        /* node URL */
        if (PG_ARGISNULL(_arg_node_uri)) {
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("node URL can't be null"),
                                 errdetail("Node URL must be valid URL to HyperEstraier node")));
        }
        node_url = _textout(PG_GETARG_TEXT_P(_arg_node_uri));

        /* login and password */
        if (PG_ARGISNULL(_arg_login) || PG_ARGISNULL(_arg_passwd)) {
                ereport(ERROR,
                                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                 errmsg("username and password can't be NULL"),
                                 errdetail("You must specify valid username and password to HyperEstraier node")));
        }
        user = _textout(PG_GETARG_TEXT_P(_arg_login));
        passwd = _textout(PG_GETARG_TEXT_P(_arg_passwd));

        /* depth of search */
        if (PG_ARGISNULL(_arg_depth)) {
                depth = 0;
        } else {
                depth = PG_GETARG_INT32(_arg_depth);
        }

        /* query string */
        if (PG_ARGISNULL(_arg_query)) {
                query = "";
        } else {
                query = _textout(PG_GETARG_TEXT_P(_arg_query));
        }

        /* atribute filter */
        if (PG_ARGISNULL(_arg_attr)) {
                attr = "";
        } else {
                attr = _textout(PG_GETARG_TEXT_P(_arg_attr));
        }
        
        /* sort order */
        if (PG_ARGISNULL(_arg_order)) {
                order = "";
        } else {
                order = _textout(PG_GETARG_TEXT_P(_arg_order));
        }


        /* limit */
        if (PG_ARGISNULL(_arg_limit)) {
                limit = 0;
        } else {
                limit = PG_GETARG_INT32(_arg_limit);
        }

        /* offset */
        if (PG_ARGISNULL(_arg_offset)) {
                offset = 0;
        } else {
                offset = PG_GETARG_INT32(_arg_offset);
        }

        /* initialize the network environment */
        if(!est_init_net_env()){
                ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED),
                        errmsg("pgest_node: can't create network enviroment")));
        }

        /* create the node connection object */
        elog(DEBUG1, "pgest_node: est_node_new(%s) as %s", node_url, user);
        node = est_node_new(node_url);
        est_node_set_auth(node, user, passwd);

        elog(DEBUG1, "pgest_node: node: %s (d:%d) query[%s] attr[%s] limit %d offset %d", node_url, depth, query, (PG_ARGISNULL(_arg_attr) ? "NULL" : attr), limit, offset);
        
        /* create a search condition object */
        if (!(cond = est_cond_new())) {
                ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED),
                        errmsg("pgest_node: est_cond_new failed")));
        }
        
        /* set the search phrase to the search condition object */
        if (! PG_ARGISNULL(_arg_query) && strlen(query) > 0)
                est_cond_set_phrase(cond, query);

        /* minimum valid attribute length is 10: @a STREQ a */
        if (! PG_ARGISNULL(_arg_attr) && strlen(attr) >= 10) {
                elog(DEBUG1,"attributes: %s", attr);
                cond_add_attr(cond, attr);
        }

        /* set the search phrase to the search condition object */
        if (! PG_ARGISNULL(_arg_order) && strlen(order) > 0) {
                elog(DEBUG1,"est_cond_set_order(%s)", order);
                est_cond_set_order(cond, order);
        }

        if (limit) {
                elog(DEBUG1,"est_cond_set_max(%d)", limit + offset);
                est_cond_set_max(cond, limit + offset);
        }

        if (offset) {
                elog(DEBUG1,"est_cond_set_skip(%d)", offset);
                est_cond_set_skip(cond, offset);
        }

        /* get the result of search */
        nres = est_node_search(node, cond, depth);

        if (! nres) {
                int status = est_node_status(node);
                est_cond_delete(cond);
                est_node_delete(node);
                est_free_net_env();
                ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED),
                        errmsg("pgest_node: search failed, node status %d", status)));
        }

        /* get number of results */
        resnum = est_noderes_doc_num(nres);

        /* check if results exists */
        if ( 0 == resnum ) {
                elog(INFO, "pgest_node: no results for: %s", query );
        }

        /* total number of tuples to be returned */
        if (limit && limit < resnum) {
                nrows = limit;
        } else {
                nrows = resnum;
        }

        /* get hints */
        hints = est_noderes_hints(nres);

        elog(DEBUG1, "pgest_node: found %d hits for %s", resnum, query);


        values = (char **) palloc(ncols * sizeof(char *));

        for (i = 0; i < nrows; i++)
        {

                /* get result from estraier */
                if (! ( rdoc = est_noderes_get_doc(nres, i) )) {
                        elog(INFO, "pgest_node: can't find result %d", i + offset);
                } else {
                        elog(DEBUG1, "URI: %s\n Title: %s\n",
                                est_resdoc_attr(rdoc, "@uri"),
                                est_resdoc_attr(rdoc, "@title")
                        );
                }

                /* iterate over results */
                for (j = 0; j < ncols; j++)
                {
                        bool    isnull;
                        char    *attr;  /* current attribute name */
                        char    *hint;  /* position of current hint in attribute */
                        char    *hint_val;

                        /* array value of this position */
                        indx[0] = j + attr_dim_lower_bounds[0];

                        dvalue = array_ref(attr_arr, attr_ndims, indx, -1, attr_len, attr_byval, attr_align, &isnull);
                        attr = (char *)DirectFunctionCall1(textout, dvalue);

                        if (!isnull && (hint = strstr(attr, HINTS_PREFIX)) != NULL) {
                                /* skip HINTS. prefix */
                                hint += strlen(HINTS_PREFIX);

                                hint_val = (char *)cbmapget(hints, hint, -1, NULL);
                                elog(DEBUG2, "hint %s = %s", hint, hint_val);

                                if (hint_val != NULL) {
                                        values[j] = DatumGetCString( hint_val );
                                } else {
                                        elog(INFO, "can't get hint in results: %s", hint);
                                        values[j] = NULL;
                                }
                        } else if (!isnull && rdoc)
                                values[j] = DatumGetCString( node_attr2text(rdoc, attr) );
                        else
                                values[j] = NULL;
                }
                /* construct the tuple */
                tuple = BuildTupleFromCStrings(attinmeta, values);

                /* now store it */
                tuplestore_puttuple(tupstore, tuple);

        }

        tuplestore_donestoring(tupstore);
        rsinfo->setResult = tupstore;

        /*
         * SFRM_Materialize mode expects us to return a NULL Datum. The actual
         * tuples are in our tuplestore and passed back through
         * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
         * that we actually used to build our tuples with, so the caller can
         * verify we did what it was expecting.
         */
        rsinfo->setDesc = tupdesc;
        MemoryContextSwitchTo(oldcontext);

        /* delete the node result object */
        est_noderes_delete(nres);

        /* destroy the search condition object */                          
        est_cond_delete(cond);

        /* destroy the node object */
        est_node_delete(node);

        /* free the networking environment */
        est_free_net_env();

        return (Datum) 0;
}

/* make text var from node attr */
char *node_attr2text(ESTRESDOC *rdoc, char *attr) {
        char *val;
        const char *attrval;
        int len;
        int attrlen;

        if (! rdoc) return (Datum) NULL;

        elog(DEBUG1, "doc: %p, attr: %s", rdoc, attr);

        if ( (attrval = est_resdoc_attr(rdoc, attr)) && (attrlen = strlen(attrval)) ) {
                val = (char *) palloc(attrlen * sizeof(char));
        } else {
                return (Datum) NULL;
        }

        len = strlen(attrval);
        elog(DEBUG1, "node_attr2text(%s) = '%s' %d bytes", attr, attrval, len);

        len++;
        len *= sizeof(char);

        elog(DEBUG2, "palloc(%d)", len);

        val = palloc(len);

        memset(val, 0, len);
        strncpy(val, attrval, len);

        elog(DEBUG2, "val=%s", val);

        return val;
}

/* parse attributes and add them to confition */
void cond_add_attr(ESTCOND *cond, char *attr) {
        char *next;
        char *curr_attr;
        while ( strlen(attr) > 0 ) {
                printf("len [%s] = %zd\n", attr, strlen(attr));
                if ((next = strstr(attr, ATTR_DELIMITER)) != NULL) {
                        curr_attr = palloc( next - attr + 1 );
                        memcpy(curr_attr, attr, next-attr);
                        curr_attr[next-attr] = '\0';
                        next += strlen(ATTR_DELIMITER);
                } else {
                        next = "";
                        curr_attr = attr;
                }
                elog(DEBUG1, "est_cond_add_attr(%s)", curr_attr);
                est_cond_add_attr(cond, curr_attr);
                attr = next;
        }
}

/* trigger to keep data in Hyper Estraier index up-to-date */
/* CREATE FUNCTION pgest_trigger() RETURNS TRIGGER AS ... */

/*
 * UPDATE, INSERT and DELETE triggers are like this:

CREATE TRIGGER pgest_trigger_update AFTER UPDATE
        ON table_name FOR EACH ROW
        EXECUTE PROCEDURE pgest_trigger('http://localhost:1978/node/trivia','admin','admin',
                'name_of_pk', 'column', 'another_column', 'and_so_on'
        )

*/

PG_FUNCTION_INFO_V1(pgest_trigger);
Datum pgest_trigger(PG_FUNCTION_ARGS) {

        TriggerData *data;
        TupleDesc   tupdesc;
        HeapTuple   ret;

        char **args;
        char *keycol  = NULL;
        char *key     = NULL;
        char *col_data = NULL;
        int   knumber;
        int   i;
        int   create_doc = 0;
        int   edit_doc = 0;

        ESTNODE *node;
        ESTDOC *doc;


        if (! CALLED_AS_TRIGGER(fcinfo)) {
                elog(ERROR, "pgest_trigger() must be called as a trigger");
        }

        data = (TriggerData *) fcinfo->context;

        if (data->tg_trigger->tgnargs < 5)
                elog(ERROR, "pgest_trigger() requires at least 5 parameters ('http://localhost:1978/node/trivia', 'user', 'passwd', 'pk_column', 'column', ... )");

        args       = data->tg_trigger->tgargs;
        keycol     = args[3];

        tupdesc = data->tg_relation->rd_att;

        knumber = SPI_fnumber(tupdesc, keycol);
        key = SPI_getvalue(data->tg_trigtuple, tupdesc, knumber);


        /* initialize the network environment */
        if( ! est_init_net_env() )
                elog(ERROR, "pgest_trigger: network is unavailable\n");

        /* create and configure the node connection object */
        node = est_node_new( args[0] );
        est_node_set_auth(node, args[1], args[2]);


        if (TRIGGER_FIRED_BY_INSERT(data->tg_event)) {
                /* There is no old data */
                ret = data->tg_trigtuple;

                create_doc++;

        } else if (TRIGGER_FIRED_BY_UPDATE(data->tg_event)) {
                ret = data->tg_newtuple;

                edit_doc++;

        } else if (TRIGGER_FIRED_BY_DELETE(data->tg_event)) {
                /* There is no new data */
                ret = data->tg_trigtuple;

                if (! est_node_out_doc_by_uri(node, key) )
                        elog(ERROR, "est_node_doc_by_uri(%s): %d\n", key, est_node_status(node));

        } else {
                elog(ERROR, "pgest_trigger() not called from INSERT/UPDATE/DELETE");
        }

        if ( create_doc || edit_doc ) {

                if ( create_doc ) {
                        /* create a document object */
                        doc = est_doc_new();
                        est_doc_add_attr(doc, "@uri", key);

                        elog(DEBUG1, "est_doc_new @uri=%s", key);
                } else {
                        /* edit existing document */
                        doc = est_node_get_doc_by_uri(node, key);
                        if (doc == NULL)
                                elog(ERROR, "est_node_get_doc_by_uri(%s): %d\n", key, est_node_status(node));
                        elog(DEBUG1, "est_node_get_doc_by_uri(%s)", key);
                }

                for( i = 4; i < data->tg_trigger->tgnargs; i++ ) {

                        col_data = SPI_getvalue(ret, tupdesc, SPI_fnumber(tupdesc, args[i]));

                        if (data) {
                                elog(DEBUG1, " + %s = %s", args[i], col_data);
                                est_doc_add_attr(doc, args[i], col_data);
                                est_doc_add_text(doc, col_data);
                        }

                }

                if ( edit_doc ) {
                        /* update existing document */
                        if( ! est_node_edit_doc(node, doc) )
                                elog(ERROR, "est_node_edit_doc: %d\n", est_node_status(node));
                } else {
                        /* register the document object to the node */
                        if( ! est_node_put_doc(node, doc) )
                                elog(ERROR, "est_node_put_doc: %d\n", est_node_status(node));
                }

                /* destroy the document object */
                est_doc_delete(doc);

        }

        /* destroy the node object */
        est_node_delete(node);
        /* free the networking environment */
        est_free_net_env();


        return PointerGetDatum(ret);
}
