Put local variables footer in all c, h files.
[idzebra-moved-to-github.git] / rset / rset.c
1 /* $Id: rset.c,v 1.53 2006-05-10 08:13:33 adam Exp $
2    Copyright (C) 1995-2005
3    Index Data ApS
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23 #include <stdio.h>
24 #include <string.h>
25 #include <idzebra/util.h>
26 #include <assert.h>
27 #include <yaz/nmem.h>
28 #include <rset.h>
29
30 static int log_level = 0;
31 static int log_level_initialized = 0;
32
33 /**
34    \brief Common constuctor for RFDs
35    \param rs Result set handle.
36    
37    Creates an rfd. Either allocates a new one, in which case the priv 
38    pointer is null, and will have to be filled in, or picks up one 
39    from the freelist, in which case the priv is already allocated,
40    and presumably everything that hangs from it as well 
41 */
42 RSFD rfd_create_base(RSET rs)
43 {
44     RSFD rnew = rs->free_list;
45
46     if (rnew) 
47     {
48         rs->free_list = rnew->next;
49         assert(rnew->rset==rs);
50         yaz_log(log_level, "rfd_create_base (fl): rfd=%p rs=%p fl=%p priv=%p", 
51                 rnew, rs, rs->free_list, rnew->priv); 
52     } 
53     else
54     {
55         rnew = nmem_malloc(rs->nmem, sizeof(*rnew));
56         rnew->counted_buf = nmem_malloc(rs->nmem, rs->keycontrol->key_size);
57         rnew->priv = 0;
58         rnew->rset = rs;
59         yaz_log(log_level, "rfd_create_base (new): rfd=%p rs=%p fl=%p priv=%p", 
60                 rnew, rs, rs->free_list, rnew->priv); 
61     }
62     rnew->next = rs->use_list;
63     rs->use_list = rnew;
64     rnew->counted_items = 0;
65     return rnew;
66 }
67
68 /**
69    \brief Closes a result set RFD handle
70    \param rfd the RFD handle.
71 */
72 void rset_close(RSFD rfd)
73 {
74     RSFD *pfd;
75     RSET rs = rfd->rset;
76
77     if (rs->hits_count == 0)
78     {
79         TERMID termid;
80         char buf[100];
81         while(rfd->counted_items <= rs->hits_limit
82               && rset_default_read(rfd, buf, &termid))
83             ;
84         
85         rs->hits_count = rfd->counted_items;
86         yaz_log(log_level, "rset_close rset=%p hits_count=" ZINT_FORMAT
87                 " hits_limit=" ZINT_FORMAT,
88                 rs, rs->hits_count, rs->hits_limit);
89         rs->hits_approx = 0;
90         if (rs->hits_count > rs->hits_limit)
91         {
92             double cur, tot;
93             zint est;
94             rset_pos(rfd, &cur, &tot); 
95             if (tot > 0) {
96                 int i;
97                 double ratio = cur/tot;
98                 est = (zint)(0.5 + rs->hits_count / ratio);
99                 yaz_log(log_level, "Estimating hits (%s) "
100                         "%0.1f->" ZINT_FORMAT
101                         "; %0.1f->" ZINT_FORMAT,
102                         rs->control->desc,
103                         cur, rs->hits_count,
104                         tot, est);
105                 i = 0; /* round to significant digits */
106                 while (est > rs->hits_round) {
107                     est /= 10;
108                     i++;
109                 }
110                 while (i--)
111                     est *= 10;
112                 rs->hits_count = est;
113                 rs->hits_approx = 1;
114             }
115         }
116         yaz_log(log_level, "rset_close p=%p count=" ZINT_FORMAT, rs,
117                 rs->hits_count);
118     }
119     (*rs->control->f_close)(rfd);
120     
121     yaz_log(log_level, "rfd_delete_base: rfd=%p rs=%p priv=%p fl=%p",
122             rfd, rs, rfd->priv, rs->free_list); 
123     for (pfd = &rs->use_list; *pfd; pfd = &(*pfd)->next)
124         if (*pfd == rfd)
125         {
126             *pfd = (*pfd)->next;
127             rfd->next = rs->free_list;
128             rs->free_list = rfd;
129             return;
130         }
131     yaz_log(YLOG_WARN, "rset_close handle not found. type=%s",
132             rs->control->desc);
133 }
134
135 /**
136    \brief Common constuctor for RSETs
137    \param sel The interface control handle
138    \param nmem The memory handle for it.
139    \param kcontrol Key control info (decode, encode, comparison etc)
140    \param scope scope for set
141    \param term Information about term for it (NULL for none).
142    \param no_children number of child rsets (0 for none)
143    \param children child rsets (NULL for none).
144    
145    Creates an rfd. Either allocates a new one, in which case the priv 
146    pointer is null, and will have to be filled in, or picks up one 
147    from the freelist, in which case the priv is already allocated,
148    and presumably everything that hangs from it as well 
149 */
150 RSET rset_create_base(const struct rset_control *sel, 
151                       NMEM nmem, struct rset_key_control *kcontrol,
152                       int scope, TERMID term,
153                       int no_children, RSET *children)
154 {
155     RSET rset;
156     assert(nmem);
157     if (!log_level_initialized) 
158     {
159         log_level = yaz_log_module_level("rset");
160         log_level_initialized = 1;
161     }
162
163     rset = (RSET) nmem_malloc(nmem, sizeof(*rset));
164     yaz_log(log_level, "rs_create(%s) rs=%p (nm=%p)", sel->desc, rset, nmem); 
165     yaz_log(log_level, " ref_id=%s limit=" ZINT_FORMAT, 
166             (term && term->ref_id ? term->ref_id : "null"),
167             rset->hits_limit);
168     rset->nmem = nmem;
169     rset->control = sel;
170     rset->refcount = 1;
171     rset->priv = 0;
172     rset->free_list = NULL;
173     rset->use_list = NULL;
174     rset->hits_count = 0;
175     rset->hits_limit = 0;
176     rset->hits_round = 1000;
177     rset->keycontrol = kcontrol;
178     (*kcontrol->inc)(kcontrol);
179     rset->scope = scope;
180     rset->term = term;
181     if (term)
182     {
183         term->rset = rset;
184         rset->hits_limit = term->hits_limit;
185     }
186     rset->no_children = no_children;
187     rset->children = 0;
188     if (no_children)
189     {
190         rset->children = (RSET*)
191             nmem_malloc(rset->nmem, no_children*sizeof(RSET *));
192         memcpy(rset->children, children, no_children*sizeof(RSET *));
193     }
194     return rset;
195 }
196
197 /**
198    \brief Destructor RSETs
199    \param rs Handle for result set.
200    
201    Destroys a result set and all its children.
202    The f_delete method of control is called for the result set.
203 */
204 void rset_delete(RSET rs)
205 {
206     (rs->refcount)--;
207     yaz_log(log_level, "rs_delete(%s), rs=%p, refcount=%d",
208             rs->control->desc, rs, rs->refcount); 
209     if (!rs->refcount)
210     {
211         int i;
212         if (rs->use_list)
213             yaz_log(YLOG_WARN, "rs_delete(%s) still has RFDs in use",
214                     rs->control->desc);
215         for (i = 0; i<rs->no_children; i++)
216             rset_delete(rs->children[i]);
217         (*rs->control->f_delete)(rs);
218         (*rs->keycontrol->dec)(rs->keycontrol);
219     }
220 }
221
222 /**
223    \brief Test for last use of RFD
224    \param rfd RFD handle.
225    
226    Returns 1 if this RFD is the last reference to it; 0 otherwise.
227 */
228 int rfd_is_last(RSFD rfd)
229 {
230     if (rfd->rset->use_list == rfd && rfd->next == 0)
231         return 1;
232     return 0;
233 }
234
235 /**
236    \brief Duplicate an RSET
237    \param rs Handle for result set.
238    
239    Duplicates a result set by incrementing the reference count to it.
240 */
241 RSET rset_dup (RSET rs)
242 {
243     (rs->refcount)++;
244     yaz_log(log_level, "rs_dup(%s), rs=%p, refcount=%d",
245             rs->control->desc, rs, rs->refcount); 
246     (*rs->keycontrol->inc)(rs->keycontrol);
247     return rs;
248 }
249
250 /** 
251     \brief Estimates hit count for result set.
252     \param rs Result Set.
253
254     rset_count uses rset_pos to get the total and returns that.
255     This is ok for rsisamb/c/s, and for some other rsets, but in case of
256     booleans etc it will give bad estimate, as nothing has been read
257     from that rset
258 */
259 zint rset_count(RSET rs)
260 {
261     double cur, tot;
262     RSFD rfd = rset_open(rs, 0);
263     rset_pos(rfd, &cur, &tot);
264     rset_close(rfd);
265     return (zint) tot;
266 }
267
268 /**
269    \brief is a getterms function for those that don't have any
270    \param ct result set handle
271    \param terms array of terms (0..maxterms-1)
272    \param maxterms length of terms array
273    \param curterm current size of terms array
274
275    If there is a term associated with rset the term is appeneded; otherwise
276    the terms array is untouched but curterm is incremented anyway.
277 */
278 void rset_get_one_term(RSET ct, TERMID *terms, int maxterms, int *curterm)
279 {
280     if (ct->term)
281     {
282         if (*curterm < maxterms)
283             terms[*curterm] = ct->term;
284         (*curterm)++;
285     }
286 }
287
288 struct ord_list *ord_list_create(NMEM nmem)
289 {
290     return 0;
291 }
292
293 struct ord_list *ord_list_append(NMEM nmem, struct ord_list *list,
294                                         int ord)
295 {
296     struct ord_list *n = nmem_malloc(nmem, sizeof(*n));
297     n->ord = ord;
298     n->next = list;
299     return n;
300 }
301
302 struct ord_list *ord_list_dup(NMEM nmem, struct ord_list *list)
303 {
304     struct ord_list *n = ord_list_create(nmem);
305     for (; list; list = list->next)
306         n = ord_list_append(nmem, n, list->ord);
307     return n;
308 }
309
310 /**
311    \brief Creates a TERMID entry.
312    \param name Term/Name buffer with given length
313    \param length of term
314    \param flags for term
315    \param type Term Type, Z_Term_general, Z_Term_characterString,..
316    \param nmem memory for term.
317    \param ol ord list
318    \param reg_type register type
319    \param hits_limit limit before counting stops and gets approximate
320    \param ref_id supplied ID for term that can be used to identify this
321 */
322 TERMID rset_term_create(const char *name, int length, const char *flags,
323                         int type, NMEM nmem, struct ord_list *ol,
324                         int reg_type,
325                         zint hits_limit, const char *ref_id)
326
327 {
328     TERMID t;
329     yaz_log (log_level, "term_create '%s' %d f=%s type=%d nmem=%p",
330             name, length, flags, type, nmem);
331     t= (TERMID) nmem_malloc(nmem, sizeof(*t));
332     if (!name)
333         t->name = NULL;
334     else if (length == -1)
335         t->name = nmem_strdup(nmem, name);
336     else
337         t->name = nmem_strdupn(nmem, name, length);
338     if (!ref_id)
339         t->ref_id = 0;
340     else
341         t->ref_id = nmem_strdup(nmem, ref_id);
342     if (!flags)
343         t->flags = NULL;
344     else
345         t->flags = nmem_strdup(nmem, flags);
346     t->hits_limit = hits_limit;
347     t->type = type;
348     t->reg_type = reg_type;
349     t->rankpriv = 0;
350     t->rset = 0;
351     t->ol = ord_list_dup(nmem, ol);
352     return t;
353 }
354
355 int rset_default_read(RSFD rfd, void *buf, TERMID *term)
356 {
357     RSET rset = rfd->rset;
358     int rc = (*rset->control->f_read)(rfd, buf, term);
359     if (rc > 0)
360     {
361         if (rfd->counted_items == 0 ||
362             (rset->keycontrol->cmp)(buf, rfd->counted_buf) > rset->scope)
363         {
364             memcpy(rfd->counted_buf, buf, rset->keycontrol->key_size);
365             rfd->counted_items++;
366         }
367     }
368     return rc;
369 }
370
371 int rset_default_forward(RSFD rfd, void *buf, TERMID *term,
372                          const void *untilbuf)
373 {
374     RSET rset = rfd->rset;
375     int more;
376
377     if (rset->control->f_forward &&
378         rfd->counted_items >= rset->hits_limit)
379     {
380         assert (rset->control->f_forward != rset_default_forward);
381         return rset->control->f_forward(rfd, buf, term, untilbuf);
382     }
383     
384     while ((more = rset_read(rfd, buf, term)) > 0)
385     {
386         if ((rfd->rset->keycontrol->cmp)(untilbuf, buf) <= 1)
387             break;
388     }
389     if (log_level)
390         yaz_log (log_level, "rset_default_forward exiting m=%d c=%d",
391                  more, rset->scope);
392     
393     return more;
394 }
395
396 void rset_visit(RSET rset, int level)
397 {
398     int i;
399     yaz_log(YLOG_LOG, "%*s%c " ZINT_FORMAT, level, "",
400             rset->hits_approx ? '~' : '=',
401             rset->hits_count);
402     for (i = 0; i<rset->no_children; i++)
403         rset_visit(rset->children[i], level+1);
404 }
405
406 /*
407  * Local variables:
408  * c-basic-offset: 4
409  * indent-tabs-mode: nil
410  * End:
411  * vim: shiftwidth=4 tabstop=8 expandtab
412  */
413