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 */

/* 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);
        }

        /* 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;
                SW_RESULT       *sw_res;        /* one row from swish-e results */

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

                if (! swish_results) {
                        elog(ERROR, "pgswish: no swish-e results");
                        SRF_RETURN_DONE(funcctx);
                }
                
                elog(INFO, "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.
                 */
                values = (char **) palloc(4 * sizeof(char *));

                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" )
                );

                elog(INFO, "swishdocpath: %s", prop2text( sw_res, "swishdocpath" ) );
                values[0] = prop2int( sw_res, "swishrank" );
                values[1] = prop2text( sw_res, "swishdocpath" );
                values[2] = prop2text( sw_res, "swishtitle" );
                values[3] = prop2int( sw_res, "swishdocsize" );
                
                /* build a tuple */
                tuple = BuildTupleFromCStrings(attinmeta, values);

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

                /* clean up ? */

                elog(INFO, "row: %s|%s|%s|%s",values[0],values[1],values[2],values[3]);
        
                SRF_RETURN_NEXT(funcctx, result);
        } else {
                /* free swish object and close */
                Free_Search_Object( search );
                SwishClose( swish_handle );

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

/*
 * elog errors
 *
 */

char *prop2text(SW_RESULT sw_res, char *propname) {
        char *val;
        char *prop;
        int len;

        elog(INFO, "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(INFO, "palloc(%d)", len);

        val = palloc(len);

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

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

        return val;
}

char *prop2int(SW_RESULT sw_res, char *propname) {
        char *val;
        unsigned long prop;
        int len;

        elog(INFO, "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(INFO, "palloc(%d)", len);

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

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

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

        return val;
}


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 );

        /* do when there is no more left */
}

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