/[pgswish]/trunk/pgswish.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/pgswish.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 12 by dpavlin, Sat Feb 19 15:09:05 2005 UTC revision 16 by dpavlin, Sun Feb 20 21:51:56 2005 UTC
# Line 25  Line 25 
25  #include "fmgr.h"  #include "fmgr.h"
26  #include "funcapi.h"  #include "funcapi.h"
27  #include "utils/builtins.h"  #include "utils/builtins.h"
28    #include "utils/array.h"
29    #include "miscadmin.h"
30  #include <swish-e.h>  #include <swish-e.h>
31    
32  #define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))  #define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))
# Line 36  Line 38 
38  SW_HANDLE   swish_handle = NULL;/* Database handle */  SW_HANDLE   swish_handle = NULL;/* Database handle */
39  SW_SEARCH   search = NULL;      /* search handle -- holds search parameters */  SW_SEARCH   search = NULL;      /* search handle -- holds search parameters */
40  SW_RESULTS  swish_results = NULL;       /* results handle -- holds list of results */  SW_RESULTS  swish_results = NULL;       /* results handle -- holds list of results */
41    SW_RESULT   *sw_res = NULL;     /* one row from swish-e results */
42    
43  /* define PostgreSQL v1 function */  /* define PostgreSQL v1 function */
44  PG_FUNCTION_INFO_V1(pgswish);  PG_FUNCTION_INFO_V1(pgswish);
# Line 114  Datum pgswish(PG_FUNCTION_ARGS) { Line 117  Datum pgswish(PG_FUNCTION_ARGS) {
117                  funcctx->attinmeta = attinmeta;                  funcctx->attinmeta = attinmeta;
118    
119                  MemoryContextSwitchTo(oldcontext);                  MemoryContextSwitchTo(oldcontext);
120    
121                    elog(INFO, "SRF_IS_FIRSTCALL done");
122          }          }
123    
124          /* stuff done on every call of the function */          /* stuff done on every call of the function */
# Line 128  Datum pgswish(PG_FUNCTION_ARGS) { Line 133  Datum pgswish(PG_FUNCTION_ARGS) {
133                  char            **values;                  char            **values;
134                  HeapTuple       tuple;                  HeapTuple       tuple;
135                  Datum           result;                  Datum           result;
                 SW_RESULT       *sw_res;        /* one row from swish-e results */  
136    
137                  elog(INFO, "pgswish: in loop %d", call_cntr);                  elog(INFO, "pgswish: loop count %d", call_cntr);
138    
139                  if (! swish_results) {                  if (! swish_results) {
140                          elog(ERROR, "pgswish: no swish-e results");                          elog(ERROR, "pgswish: no swish-e results");
141                          SRF_RETURN_DONE(funcctx);                          SRF_RETURN_DONE(funcctx);
142                  }                  }
143                                    
144                  elog(INFO, "pgswish: check for swish-e error");                  elog(DEBUG1, "pgswish: check for swish-e error");
145                  error_or_abort( swish_handle );                  error_or_abort( swish_handle );
146    
147                  /*                  /*
# Line 145  Datum pgswish(PG_FUNCTION_ARGS) { Line 149  Datum pgswish(PG_FUNCTION_ARGS) {
149                   * This should be an array of C strings which will                   * This should be an array of C strings which will
150                   * be processed later by the type input functions.                   * be processed later by the type input functions.
151                   */                   */
                 values = (char **) palloc(4 * sizeof(char *));  
152    
153                  sw_res = SwishNextResult( swish_results );                  sw_res = SwishNextResult( swish_results );
154                  if (! sw_res) {                  if (! sw_res) {
# Line 164  Datum pgswish(PG_FUNCTION_ARGS) { Line 167  Datum pgswish(PG_FUNCTION_ARGS) {
167                          SwishResultPropertyULong ( sw_res, "swishfilenum" )                          SwishResultPropertyULong ( sw_res, "swishfilenum" )
168                  );                  );
169    
170                  elog(INFO, "swishdocpath: %s", prop2text( sw_res, "swishdocpath" ) );                  values = (char **) palloc(4 * sizeof(char *));
171    
172                  values[0] = prop2int( sw_res, "swishrank" );                  values[0] = prop2int( sw_res, "swishrank" );
173                  values[1] = prop2text( sw_res, "swishdocpath" );                  values[1] = prop2text( sw_res, "swishdocpath" );
174                  values[2] = prop2text( sw_res, "swishtitle" );                  values[2] = prop2text( sw_res, "swishtitle" );
175                  values[3] = prop2int( sw_res, "swishdocsize" );                  values[3] = prop2int( sw_res, "swishdocsize" );
176                    
177    /*
178                    values[0] = (char *) palloc(16 * sizeof(char));
179                    snprintf(values[0], 16, "%d", 1);
180                    values[1] = (char *) palloc(16 * sizeof(char));
181                    snprintf(values[1], 16, "%d", 2);
182                    values[2] = (char *) palloc(16 * sizeof(char));
183                    snprintf(values[2], 16, "%d", 3);
184                    values[3] = (char *) palloc(16 * sizeof(char));
185                    snprintf(values[3], 16, "%d", 4);
186    */
187    
188                  /* build a tuple */                  /* build a tuple */
189                  tuple = BuildTupleFromCStrings(attinmeta, values);                  tuple = BuildTupleFromCStrings(attinmeta, values);
190    
# Line 177  Datum pgswish(PG_FUNCTION_ARGS) { Line 192  Datum pgswish(PG_FUNCTION_ARGS) {
192                  result = TupleGetDatum(slot, tuple);                  result = TupleGetDatum(slot, tuple);
193    
194                  /* clean up ? */                  /* clean up ? */
195                    pfree(values[0]);
196                    pfree(values[1]);
197                    pfree(values[2]);
198                    pfree(values[3]);
199                    pfree(values);
200                    
201                  elog(INFO, "row: %s|%s|%s|%s",values[0],values[1],values[2],values[3]);                  elog(INFO, "row: %s|%s|%s|%s",values[0],values[1],values[2],values[3]);
202                    
203                  SRF_RETURN_NEXT(funcctx, result);                  SRF_RETURN_NEXT(funcctx, result);
204          } else {          } else {
205                    elog(INFO, "loop over");
206    
207                  /* free swish object and close */                  /* free swish object and close */
208                  Free_Search_Object( search );                  Free_Search_Object( search );
209                  SwishClose( swish_handle );                  SwishClose( swish_handle );
# Line 191  Datum pgswish(PG_FUNCTION_ARGS) { Line 213  Datum pgswish(PG_FUNCTION_ARGS) {
213          }          }
214  }  }
215    
216  /*  /* work in progress */
217   * elog errors  PG_FUNCTION_INFO_V1(pgswish2);
218   *  Datum pgswish2(PG_FUNCTION_ARGS)
219   */  {
220            int             ncols = 2;
221            int             nrows = 3;
222            int16           typlen;
223            bool            typbyval;
224            char            typalign;
225            ReturnSetInfo   *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
226            AttInMetadata   *attinmeta;
227            TupleDesc       tupdesc;
228            Tuplestorestate *tupstore = NULL;
229            HeapTuple       tuple;
230            MemoryContext   per_query_ctx;
231            MemoryContext   oldcontext;
232            Datum           dvalue;
233            char            **values;
234            int             rsinfo_ncols;
235            int             i, j;
236    
237            /* check to see if caller supports us returning a tuplestore */
238            if (!rsinfo || !(rsinfo->allowedModes & SFRM_Materialize))
239                    ereport(ERROR,
240                                    (errcode(ERRCODE_SYNTAX_ERROR),
241                                     errmsg("materialize mode required, but it is not " \
242                                                    "allowed in this context")));
243    
244            /* get the requested return tuple description */
245            tupdesc = rsinfo->expectedDesc;
246            rsinfo_ncols = tupdesc->natts;
247    
248            /*
249             * The requested tuple description better match up with the array
250             * we were given.
251             */
252            elog(INFO, "rsinfo_ncols = %d, ncols = %d", rsinfo_ncols, ncols);
253    
254            /* OK, use it */
255            attinmeta = TupleDescGetAttInMetadata(tupdesc);
256    
257            /* Now go to work */
258            rsinfo->returnMode = SFRM_Materialize;
259    
260            per_query_ctx = fcinfo->flinfo->fn_mcxt;
261            oldcontext = MemoryContextSwitchTo(per_query_ctx);
262    
263            /* initialize our tuplestore */
264            tupstore = tuplestore_begin_heap(true, false, SortMem);
265    
266            values = (char **) palloc(ncols * sizeof(char *));
267    
268            for (i = 0; i < nrows; i++)
269            {
270                    for (j = 0; j < ncols; j++)
271                    {
272                            values[j] = DatumGetCString( "foo" );
273                    }
274                    /* construct the tuple */
275                    tuple = BuildTupleFromCStrings(attinmeta, values);
276    
277                    /* now store it */
278                    tuplestore_puttuple(tupstore, tuple);
279            }
280    
281            tuplestore_donestoring(tupstore);
282            rsinfo->setResult = tupstore;
283    
284            /*
285             * SFRM_Materialize mode expects us to return a NULL Datum. The actual
286             * tuples are in our tuplestore and passed back through
287             * rsinfo->setResult. rsinfo->setDesc is set to the tuple description
288             * that we actually used to build our tuples with, so the caller can
289             * verify we did what it was expecting.
290             */
291            rsinfo->setDesc = tupdesc;
292            MemoryContextSwitchTo(oldcontext);
293    
294            return (Datum) 0;
295    }
296    
297    
298    /* make text var prom property */
299  char *prop2text(SW_RESULT sw_res, char *propname) {  char *prop2text(SW_RESULT sw_res, char *propname) {
300          char *val;          char *val;
301          char *prop;          char *prop;
302          int len;          int len;
303    
304          elog(INFO, "prop2text(%s)", propname);          elog(DEBUG1, "prop2text(%s)", propname);
305    
306          prop = SwishResultPropertyStr( sw_res, propname );          prop = SwishResultPropertyStr( sw_res, propname );
307          error_or_abort( swish_handle );          error_or_abort( swish_handle );
# Line 212  char *prop2text(SW_RESULT sw_res, char * Line 312  char *prop2text(SW_RESULT sw_res, char *
312          len++;          len++;
313          len *= sizeof(char);          len *= sizeof(char);
314    
315          elog(INFO, "palloc(%d)", len);          elog(DEBUG1, "palloc(%d)", len);
316    
317          val = palloc(len);          val = palloc(len);
318    
319          memset(val, 0, len);          memset(val, 0, len);
320          strncpy(val, prop, len);          strncpy(val, prop, len);
321    
322          elog(INFO, "val=%s", val);          elog(DEBUG1, "val=%s", val);
323    
324          return val;          return val;
325  }  }
326    
327    /* make integer variable from property */
328  char *prop2int(SW_RESULT sw_res, char *propname) {  char *prop2int(SW_RESULT sw_res, char *propname) {
329          char *val;          char *val;
330          unsigned long prop;          unsigned long prop;
331          int len;          int len;
332    
333          elog(INFO, "prop2int(%s)", propname);          elog(DEBUG1, "prop2int(%s)", propname);
334    
335          prop = SwishResultPropertyULong( sw_res, propname );          prop = SwishResultPropertyULong( sw_res, propname );
336          error_or_abort( swish_handle );          error_or_abort( swish_handle );
# Line 237  char *prop2int(SW_RESULT sw_res, char *p Line 338  char *prop2int(SW_RESULT sw_res, char *p
338          elog(INFO, "prop2int(%s) = %lu", propname, prop);          elog(INFO, "prop2int(%s) = %lu", propname, prop);
339    
340          len = 128 * sizeof(char);          len = 128 * sizeof(char);
341          elog(INFO, "palloc(%d)", len);          elog(DEBUG1, "palloc(%d)", len);
342    
343          val = palloc(len);          val = palloc(len);
344          memset(val, 0, len);          memset(val, 0, len);
345    
346          snprintf(val, len, "%lu", prop);          snprintf(val, len, "%lu", prop);
347    
348          elog(INFO, "val=%s", val);          elog(DEBUG1, "val=%s", val);
349    
350          return val;          return val;
351  }  }
352    
353    
354    /*
355     * check if swish has returned error, and elog it.
356     */
357  static void error_or_abort( SW_HANDLE swish_handle ) {  static void error_or_abort( SW_HANDLE swish_handle ) {
358          if ( !SwishError( swish_handle ) )          if ( !SwishError( swish_handle ) )
359                  return;                  return;
# Line 263  static void error_or_abort( SW_HANDLE sw Line 367  static void error_or_abort( SW_HANDLE sw
367          );          );
368          if ( search ) Free_Search_Object( search );          if ( search ) Free_Search_Object( search );
369          SwishClose( swish_handle );          SwishClose( swish_handle );
   
         /* do when there is no more left */  
370  }  }
371    
Legend:
Removed from v.12  
changed lines
  Added in v.16
  ViewVC Help
Powered by ViewVC 1.1.26