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
 * - split error_or_abort
 * - use getResultPropValue not SwishResultPropertyStr
 *
 * 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 "utils/array.h"
#include "miscadmin.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)))

/* Globals */
static SW_HANDLE   swish_handle = NULL; /* Database handle */
static SW_SEARCH   search = NULL;       /* search handle -- search parameters */
static SW_RESULTS  swish_results = NULL; /* results handle -- list of results */
static 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;
        FILE            *logfh;

        /* 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 log, as well as
                 * STDOUT and STDERR (just to be sure) */
                if ( logfh = fopen("/tmp/pgswish.log", "a") ) {
                        set_error_handle( logfh );
                        elog(INFO, "loggin swish-e errors to /tmp/pgswish.log");
                        /* redirect STDOUT and STDERR to log */
                        dup2(1, logfh);
                        dup2(2, logfh);
                } else {
                        elog(INFO, "can't open /tmp/pgswish.log -- errors from swish-e won't be cought and may result in back-end crashes!");
                }

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

                swish_handle = SwishInit( index_path );

                if ( SwishError( swish_handle ) ) 
                        elog(INFO, "pgswish: SwishInit(%s) failed: %s", index_path, SwishErrorString( swish_handle ));
                
                elog(INFO, "handle: %08x", swish_handle);

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

                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);
                if (error_or_abort( swish_handle )) SRF_RETURN_DONE(funcctx);

                /* 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");
                if (error_or_abort( swish_handle )) SRF_RETURN_DONE(funcctx);

                /*
                 * 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);
                        Free_Results_Object( swish_results );
                        Free_Search_Object( search );
                        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(DEBUG1, "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);
        }
}


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

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

        prop = SwishResultPropertyStr( sw_res, propname );
        if (error_or_abort( swish_handle )) return NULL;

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

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

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

        val = palloc(len);

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

        elog(DEBUG2, "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(DEBUG2, "prop2int(%s)", propname);

        prop = SwishResultPropertyULong( sw_res, propname );
        if (error_or_abort( swish_handle )) return NULL;

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

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

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

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

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

        return val;
}


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

        /* 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 ( swish_results ) Free_Results_Object( swish_results );
        if ( search ) Free_Search_Object( search );
        SwishClose( swish_handle );

        return 1;
}

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