pgswish/trunk/pgswish.c

/*
 * integrate swish-e into PostgreSQL
 *
 * Dobrica Pavlinusic <dpavlin@rot13.org> 2005-02-18
 *
 * TODO:
 * - check null input using PG_ARGISNULL before using PG_GETARG_xxxx
 * - support composite type arguments
 *
 * 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)
 * - swish-e example src/libtest.c (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 <swish-e.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)))


SW_HANDLE   swish_handle = NULL;/* Database handle */
SW_SEARCH   search = NULL;      /* search handle -- holds search parameters */
SW_RESULTS  swish_results = NULL;       /* results handle -- holds list of results */
SW_RESULT   *sw_res = NULL;     /* one row from swish-e results */

/* define PostgreSQL v1 function */
PG_FUNCTION_INFO_V1(pgswish);
Datum pgswish(PG_FUNCTION_ARGS) {

        FuncCallContext *funcctx;
        int             call_cntr;
        int             max_calls;
        TupleDesc       tupdesc;
        TupleTableSlot  *slot;
        AttInMetadata   *attinmeta;
        char            *index_path;
        char            *query;

        /* stuff done only on the first call of the function */
        if (SRF_IS_FIRSTCALL()) {
                MemoryContext   oldcontext;

                /* take arguments from function */
                //index_path = _textout(PG_GETARG_TEXT_P(0));
                index_path = _textout(PG_GETARG_TEXT_P(0));
                query = _textout(PG_GETARG_TEXT_P(1));

                /* create a function context for cross-call persistence */
                funcctx = SRF_FIRSTCALL_INIT();

                /* switch to memory context appropriate for multiple function calls */
                oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

                
                /* Send any errors or warnings to stderr (default is stdout) */
                SwishErrorsToStderr();

                elog(INFO, "pgswish: SwishInit(%s)", index_path);
                
                swish_handle = SwishInit( index_path );

                if (! swish_handle) {
                        elog(ERROR, "pgswish: can't open %s", index_path);
                        SRF_RETURN_DONE(funcctx);
                }
                
                error_or_abort( swish_handle );
                /* set ranking scheme. default is 0 */
                SwishRankScheme( swish_handle, 0 );
                error_or_abort( swish_handle );

                elog(INFO, "pgswish: SwishQuery(%s)", query);
                /* Here's a short-cut to searching that creates a search object and searches at the same time */
                swish_results = SwishQuery( swish_handle, query);
                error_or_abort( swish_handle );

                /* total number of tuples to be returned */
                funcctx->max_calls = SwishHits( swish_results );

                /* check if results exists */
                if ( 0 == funcctx->max_calls )
                        elog(INFO, "no results for: %s", query );

                elog(INFO, "pgswish: SwishHits = %d", funcctx->max_calls);

                /* Build a tuple description for a __pgswish tuple */
                tupdesc = RelationNameGetTupleDesc("__pgswish");

                /* allocate a slot for a tuple with this tupdesc */
                slot = TupleDescGetSlot(tupdesc);

                /* assign slot to function context */
                funcctx->slot = slot;

                /*
                 * generate attribute metadata needed later to produce tuples from raw
                 * C strings
                 */
                attinmeta = TupleDescGetAttInMetadata(tupdesc);
                funcctx->attinmeta = attinmeta;

                MemoryContextSwitchTo(oldcontext);

                elog(INFO, "SRF_IS_FIRSTCALL done");
        }

        /* stuff done on every call of the function */
        funcctx = SRF_PERCALL_SETUP();

        call_cntr = funcctx->call_cntr;
        max_calls = funcctx->max_calls;
        slot = funcctx->slot;
        attinmeta = funcctx->attinmeta;
 
        if (call_cntr < max_calls) {
                char            **values;
                HeapTuple       tuple;
                Datum           result;

                elog(INFO, "pgswish: loop count %d", call_cntr);

                if (! swish_results) {
                        elog(ERROR, "pgswish: no swish-e results");
                        SRF_RETURN_DONE(funcctx);
                }
                
                elog(DEBUG1, "pgswish: check for swish-e error");
                error_or_abort( swish_handle );

                /*
                 * Prepare a values array for storage in our slot.
                 * This should be an array of C strings which will
                 * be processed later by the type input functions.
                 */

                sw_res = SwishNextResult( swish_results );
                if (! sw_res) {
                        elog(ERROR, "pgswish: swish-e sort result list: %d rows expected %d", call_cntr, max_calls - 1);
                        SRF_RETURN_DONE(funcctx);
                }
                
                elog(INFO, "Path: %s\n  Rank: %lu\n  Size: %lu\n  Title: %s\n  Index: %s\n  Modified: %s\n  Record #: %lu\n  File   #: %lu\n\n",
                        SwishResultPropertyStr   ( sw_res, "swishdocpath" ),
                        SwishResultPropertyULong ( sw_res, "swishrank" ),
                        SwishResultPropertyULong ( sw_res, "swishdocsize" ),
                        SwishResultPropertyStr   ( sw_res, "swishtitle"),
                        SwishResultPropertyStr   ( sw_res, "swishdbfile" ),
                        SwishResultPropertyStr   ( sw_res, "swishlastmodified" ),
                        SwishResultPropertyULong ( sw_res, "swishreccount" ),  /* can figure this out in loop, of course */
                        SwishResultPropertyULong ( sw_res, "swishfilenum" )
                );

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

                values[0] = prop2int( sw_res, "swishrank" );
                values[1] = prop2text( sw_res, "swishdocpath" );
                values[2] = prop2text( sw_res, "swishtitle" );
                values[3] = prop2int( sw_res, "swishdocsize" );

/*
                values[0] = (char *) palloc(16 * sizeof(char));
                snprintf(values[0], 16, "%d", 1);
                values[1] = (char *) palloc(16 * sizeof(char));
                snprintf(values[1], 16, "%d", 2);
                values[2] = (char *) palloc(16 * sizeof(char));
                snprintf(values[2], 16, "%d", 3);
                values[3] = (char *) palloc(16 * sizeof(char));
                snprintf(values[3], 16, "%d", 4);
*/
                
                /* build a tuple */
                tuple = BuildTupleFromCStrings(attinmeta, values);

                /* make the tuple into a datum */
                result = TupleGetDatum(slot, tuple);

                /* clean up ? */
                pfree(values[0]);
                pfree(values[1]);
                pfree(values[2]);
                pfree(values[3]);
                pfree(values);
                
                elog(INFO, "row: %s|%s|%s|%s",values[0],values[1],values[2],values[3]);
        
                SRF_RETURN_NEXT(funcctx, result);
        } else {
                elog(INFO, "loop over");

                /* free swish object and close */
                Free_Search_Object( search );
                SwishClose( swish_handle );

                /* do when there is no more left */
                SRF_RETURN_DONE(funcctx);
        }
}

Datum swtextprop(PG_FUNCTION_ARGS) {
        char    *prop;
        char    *val;

        prop = _textout(PG_GETARG_TEXT_P(0));
        elog(INFO, "pgswish: swextprop(%s)", prop);

        val = prop2int( sw_res, prop );
        error_or_abort( swish_handle );

        elog(INFO, "pgswish: swextprop(%s) = '%s'", prop, val );

        PG_FREE_IF_COPY(prop, 0);
        PG_RETURN_TEXT_P( _textin(val) );
}

/* make text var prom property */
char *prop2text(SW_RESULT sw_res, char *propname) {
        char *val;
        char *prop;
        int len;

        elog(DEBUG1, "prop2text(%s)", propname);

        prop = SwishResultPropertyStr( sw_res, propname );
        error_or_abort( swish_handle );

        len = strlen(prop);
        elog(INFO, "prop2text(%s) = '%s' %d bytes", propname, prop, len);

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

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

        val = palloc(len);

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

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

        return val;
}

/* make integer variable from property */
char *prop2int(SW_RESULT sw_res, char *propname) {
        char *val;
        unsigned long prop;
        int len;

        elog(DEBUG1, "prop2int(%s)", propname);

        prop = SwishResultPropertyULong( sw_res, propname );
        error_or_abort( swish_handle );

        elog(INFO, "prop2int(%s) = %lu", propname, prop);

        len = 128 * sizeof(char);
        elog(DEBUG1, "palloc(%d)", len);

        val = palloc(len);
        memset(val, 0, len);

        snprintf(val, len, "%lu", prop);

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

        return val;
}


/*
 * check if swish has returned error, and elog it.
 */
static void error_or_abort( SW_HANDLE swish_handle ) {
        if ( !SwishError( swish_handle ) )
                return;

        /* print a message */
        elog(ERROR, 
                "pgswish error: Number [%d], Type [%s],  Optional Message: [%s]\n",
                        SwishError( swish_handle ),
                        SwishErrorString( swish_handle ),
                        SwishLastErrorMsg( swish_handle )
        );
        if ( search ) Free_Search_Object( search );
        SwishClose( swish_handle );
}

1	dpavlin	8	/*
2			* integrate swish-e into PostgreSQL
3			*
4			* Dobrica Pavlinusic <dpavlin@rot13.org> 2005-02-18
5			*
6			* TODO:
7			* - check null input using PG_ARGISNULL before using PG_GETARG_xxxx
8			* - support composite type arguments
9			*
10			* NOTES:
11			* - clear structures with memset to support hash indexes (who whould like
12			* to create hash index on table returned from function?)
13	dpavlin	10	* - number of returned rows is set by PostgreSQL evaluator, see:
14			* http://archives.postgresql.org/pgsql-hackers/2005-02/msg00546.php
15	dpavlin	8	*
16	dpavlin	9	* Based on:
17			* - C example from PostgreSQL documentation (BSD licence)
18			* - swish-e example src/libtest.c (GPL)
19			* - _textin/_textout from pgcurl.c (LGPL)
20			*
21			* This code is licenced under GPL
22	dpavlin	8	*/
23
24			#include "postgres.h"
25			#include "fmgr.h"
26			#include "funcapi.h"
27	dpavlin	9	#include "utils/builtins.h"
28	dpavlin	8	#include <swish-e.h>
29
30	dpavlin	9	#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
31			#define _textout(str) DatumGetPointer(DirectFunctionCall1(textout, PointerGetDatum(str)))
32	dpavlin	11	#define GET_STR(textp) DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(textp)))
33			#define GET_TEXT(cstrp) DatumGetTextP(DirectFunctionCall1(textin, CStringGetDatum(cstrp)))
34	dpavlin	8
35	dpavlin	9
36	dpavlin	8	SW_HANDLE swish_handle = NULL;/* Database handle */
37			SW_SEARCH search = NULL; /* search handle -- holds search parameters */
38	dpavlin	11	SW_RESULTS swish_results = NULL; /* results handle -- holds list of results */
39	dpavlin	14	SW_RESULT sw_res = NULL; / one row from swish-e results */
40	dpavlin	8
41			/* define PostgreSQL v1 function */
42			PG_FUNCTION_INFO_V1(pgswish);
43			Datum pgswish(PG_FUNCTION_ARGS) {
44
45			FuncCallContext *funcctx;
46			int call_cntr;
47			int max_calls;
48			TupleDesc tupdesc;
49			TupleTableSlot *slot;
50			AttInMetadata *attinmeta;
51	dpavlin	9	char *index_path;
52			char *query;
53	dpavlin	8
54			/* stuff done only on the first call of the function */
55			if (SRF_IS_FIRSTCALL()) {
56			MemoryContext oldcontext;
57
58	dpavlin	9	/* take arguments from function */
59			//index_path = _textout(PG_GETARG_TEXT_P(0));
60			index_path = _textout(PG_GETARG_TEXT_P(0));
61			query = _textout(PG_GETARG_TEXT_P(1));
62
63	dpavlin	8	/* create a function context for cross-call persistence */
64			funcctx = SRF_FIRSTCALL_INIT();
65
66			/* switch to memory context appropriate for multiple function calls */
67			oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
68
69	dpavlin	9
70	dpavlin	8	/* Send any errors or warnings to stderr (default is stdout) */
71			SwishErrorsToStderr();
72
73	dpavlin	9	elog(INFO, "pgswish: SwishInit(%s)", index_path);
74	dpavlin	8
75	dpavlin	9	swish_handle = SwishInit( index_path );
76	dpavlin	8
77			if (! swish_handle) {
78	dpavlin	9	elog(ERROR, "pgswish: can't open %s", index_path);
79	dpavlin	8	SRF_RETURN_DONE(funcctx);
80			}
81
82	dpavlin	12	error_or_abort( swish_handle );
83	dpavlin	8	/* set ranking scheme. default is 0 */
84	dpavlin	10	SwishRankScheme( swish_handle, 0 );
85	dpavlin	12	error_or_abort( swish_handle );
86	dpavlin	8
87	dpavlin	9	elog(INFO, "pgswish: SwishQuery(%s)", query);
88	dpavlin	8	/* Here's a short-cut to searching that creates a search object and searches at the same time */
89	dpavlin	11	swish_results = SwishQuery( swish_handle, query);
90	dpavlin	12	error_or_abort( swish_handle );
91	dpavlin	8
92			/* total number of tuples to be returned */
93	dpavlin	11	funcctx->max_calls = SwishHits( swish_results );
94	dpavlin	8
95			/* check if results exists */
96			if ( 0 == funcctx->max_calls )
97	dpavlin	9	elog(INFO, "no results for: %s", query );
98	dpavlin	8
99	dpavlin	9	elog(INFO, "pgswish: SwishHits = %d", funcctx->max_calls);
100
101	dpavlin	8	/* Build a tuple description for a __pgswish tuple */
102			tupdesc = RelationNameGetTupleDesc("__pgswish");
103
104			/* allocate a slot for a tuple with this tupdesc */
105			slot = TupleDescGetSlot(tupdesc);
106
107			/* assign slot to function context */
108			funcctx->slot = slot;
109
110			/*
111			* generate attribute metadata needed later to produce tuples from raw
112			* C strings
113			*/
114			attinmeta = TupleDescGetAttInMetadata(tupdesc);
115			funcctx->attinmeta = attinmeta;
116
117			MemoryContextSwitchTo(oldcontext);
118	dpavlin	13
119			elog(INFO, "SRF_IS_FIRSTCALL done");
120	dpavlin	8	}
121
122			/* stuff done on every call of the function */
123			funcctx = SRF_PERCALL_SETUP();
124
125			call_cntr = funcctx->call_cntr;
126			max_calls = funcctx->max_calls;
127			slot = funcctx->slot;
128			attinmeta = funcctx->attinmeta;
129
130			if (call_cntr < max_calls) {
131			char **values;
132			HeapTuple tuple;
133			Datum result;
134
135	dpavlin	13	elog(INFO, "pgswish: loop count %d", call_cntr);
136	dpavlin	11
137			if (! swish_results) {
138			elog(ERROR, "pgswish: no swish-e results");
139			SRF_RETURN_DONE(funcctx);
140			}
141
142	dpavlin	14	elog(DEBUG1, "pgswish: check for swish-e error");
143	dpavlin	12	error_or_abort( swish_handle );
144	dpavlin	11
145	dpavlin	8	/*
146			* Prepare a values array for storage in our slot.
147			* This should be an array of C strings which will
148			* be processed later by the type input functions.
149			*/
150
151	dpavlin	11	sw_res = SwishNextResult( swish_results );
152			if (! sw_res) {
153			elog(ERROR, "pgswish: swish-e sort result list: %d rows expected %d", call_cntr, max_calls - 1);
154			SRF_RETURN_DONE(funcctx);
155			}
156
157	dpavlin	12	elog(INFO, "Path: %s\n Rank: %lu\n Size: %lu\n Title: %s\n Index: %s\n Modified: %s\n Record #: %lu\n File #: %lu\n\n",
158			SwishResultPropertyStr ( sw_res, "swishdocpath" ),
159			SwishResultPropertyULong ( sw_res, "swishrank" ),
160			SwishResultPropertyULong ( sw_res, "swishdocsize" ),
161			SwishResultPropertyStr ( sw_res, "swishtitle"),
162			SwishResultPropertyStr ( sw_res, "swishdbfile" ),
163			SwishResultPropertyStr ( sw_res, "swishlastmodified" ),
164			SwishResultPropertyULong ( sw_res, "swishreccount" ), /* can figure this out in loop, of course */
165			SwishResultPropertyULong ( sw_res, "swishfilenum" )
166			);
167	dpavlin	11
168	dpavlin	13	values = (char *) palloc(4 sizeof(char *));
169
170	dpavlin	12	values[0] = prop2int( sw_res, "swishrank" );
171			values[1] = prop2text( sw_res, "swishdocpath" );
172			values[2] = prop2text( sw_res, "swishtitle" );
173			values[3] = prop2int( sw_res, "swishdocsize" );
174	dpavlin	13
175			/*
176			values[0] = (char ) palloc(16 sizeof(char));
177			snprintf(values[0], 16, "%d", 1);
178			values[1] = (char ) palloc(16 sizeof(char));
179			snprintf(values[1], 16, "%d", 2);
180			values[2] = (char ) palloc(16 sizeof(char));
181			snprintf(values[2], 16, "%d", 3);
182			values[3] = (char ) palloc(16 sizeof(char));
183			snprintf(values[3], 16, "%d", 4);
184			*/
185	dpavlin	12
186	dpavlin	8	/* build a tuple */
187			tuple = BuildTupleFromCStrings(attinmeta, values);
188
189			/* make the tuple into a datum */
190			result = TupleGetDatum(slot, tuple);
191
192	dpavlin	12	/* clean up ? */
193	dpavlin	13	pfree(values[0]);
194			pfree(values[1]);
195			pfree(values[2]);
196			pfree(values[3]);
197			pfree(values);
198
199	dpavlin	12	elog(INFO, "row: %s\|%s\|%s\|%s",values[0],values[1],values[2],values[3]);
200
201	dpavlin	8	SRF_RETURN_NEXT(funcctx, result);
202			} else {
203	dpavlin	13	elog(INFO, "loop over");
204
205	dpavlin	8	/* free swish object and close */
206			Free_Search_Object( search );
207			SwishClose( swish_handle );
208
209			/* do when there is no more left */
210			SRF_RETURN_DONE(funcctx);
211			}
212			}
213
214	dpavlin	14	Datum swtextprop(PG_FUNCTION_ARGS) {
215			char *prop;
216			char *val;
217	dpavlin	8
218	dpavlin	14	prop = _textout(PG_GETARG_TEXT_P(0));
219			elog(INFO, "pgswish: swextprop(%s)", prop);
220
221			val = prop2int( sw_res, prop );
222			error_or_abort( swish_handle );
223
224			elog(INFO, "pgswish: swextprop(%s) = '%s'", prop, val );
225
226			PG_FREE_IF_COPY(prop, 0);
227			PG_RETURN_TEXT_P( _textin(val) );
228			}
229
230			/* make text var prom property */
231	dpavlin	12	char prop2text(SW_RESULT sw_res, char propname) {
232			char *val;
233			char *prop;
234			int len;
235
236	dpavlin	14	elog(DEBUG1, "prop2text(%s)", propname);
237	dpavlin	12
238			prop = SwishResultPropertyStr( sw_res, propname );
239			error_or_abort( swish_handle );
240
241			len = strlen(prop);
242			elog(INFO, "prop2text(%s) = '%s' %d bytes", propname, prop, len);
243
244			len++;
245			len *= sizeof(char);
246
247	dpavlin	14	elog(DEBUG1, "palloc(%d)", len);
248	dpavlin	12
249			val = palloc(len);
250
251			memset(val, 0, len);
252			strncpy(val, prop, len);
253
254	dpavlin	14	elog(DEBUG1, "val=%s", val);
255	dpavlin	12
256			return val;
257			}
258
259	dpavlin	14	/* make integer variable from property */
260	dpavlin	12	char prop2int(SW_RESULT sw_res, char propname) {
261			char *val;
262			unsigned long prop;
263			int len;
264
265	dpavlin	14	elog(DEBUG1, "prop2int(%s)", propname);
266	dpavlin	12
267			prop = SwishResultPropertyULong( sw_res, propname );
268			error_or_abort( swish_handle );
269
270			elog(INFO, "prop2int(%s) = %lu", propname, prop);
271
272			len = 128 * sizeof(char);
273	dpavlin	14	elog(DEBUG1, "palloc(%d)", len);
274	dpavlin	12
275			val = palloc(len);
276			memset(val, 0, len);
277
278			snprintf(val, len, "%lu", prop);
279
280	dpavlin	14	elog(DEBUG1, "val=%s", val);
281	dpavlin	12
282			return val;
283			}
284
285
286	dpavlin	14	/*
287			* check if swish has returned error, and elog it.
288			*/
289	dpavlin	8	static void error_or_abort( SW_HANDLE swish_handle ) {
290			if ( !SwishError( swish_handle ) )
291			return;
292
293			/* print a message */
294			elog(ERROR,
295			"pgswish error: Number [%d], Type [%s], Optional Message: [%s]\n",
296			SwishError( swish_handle ),
297			SwishErrorString( swish_handle ),
298			SwishLastErrorMsg( swish_handle )
299			);
300			if ( search ) Free_Search_Object( search );
301			SwishClose( swish_handle );
302			}
303