Merge branch 'master' of ssh://git.indexdata.com/home/git/pub/idzebra
[idzebra-moved-to-github.git] / rset / rsprox.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 1994-2009 Index Data
3
4 Zebra is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24
25 #include <idzebra/util.h>
26 #include <rset.h>
27
28 #ifndef RSET_DEBUG
29 #define RSET_DEBUG 0
30 #endif
31
32 static RSFD r_open (RSET ct, int flag);
33 static void r_close (RSFD rfd);
34 static void r_delete (RSET ct);
35 static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf);
36 static int r_read (RSFD rfd, void *buf, TERMID *term);
37 static int r_write (RSFD rfd, const void *buf);
38 static void r_pos (RSFD rfd, double *current, double *total);
39 static void r_get_terms(RSET ct, TERMID *terms, int maxterms, int *curterm);
40
41 static const struct rset_control control = 
42 {
43     "prox",
44     r_delete,
45     r_get_terms,
46     r_open,
47     r_close,
48     r_forward,
49     r_pos,
50     r_read,
51     r_write,
52 };
53
54 struct rset_prox_info {
55     int ordered;
56     int exclusion;
57     int relation;
58     int distance;
59 };
60
61 struct rset_prox_rfd {
62     RSFD *rfd;
63     char **buf;  /* lookahead key buffers */
64     char *more;  /* more in each lookahead? */
65     TERMID *terms; /* lookahead terms */
66     zint hits;
67 };    
68
69
70 RSET rset_create_prox(NMEM nmem, struct rset_key_control *kcontrol,
71                       int scope,
72                       int rset_no, RSET *rset,
73                       int ordered, int exclusion,
74                       int relation, int distance)
75 {
76     RSET rnew = rset_create_base(&control, nmem, kcontrol, scope, 0,
77                                  rset_no, rset);
78     struct rset_prox_info *info;
79     info = (struct rset_prox_info *) nmem_malloc(rnew->nmem,sizeof(*info));
80     info->ordered = ordered;
81     info->exclusion = exclusion;
82     info->relation = relation;
83     info->distance = distance;
84     rnew->priv = info;
85     return rnew;
86 }
87
88 static void r_delete (RSET ct)
89 {
90 }
91
92 static RSFD r_open (RSET ct, int flag)
93 {
94     RSFD rfd;
95     struct rset_prox_rfd *p;
96     int i;
97
98     if (flag & RSETF_WRITE)
99     {
100         yaz_log(YLOG_FATAL, "prox set type is read-only");
101         return NULL;
102     }
103     rfd = rfd_create_base(ct);
104     if (rfd->priv)
105         p = (struct rset_prox_rfd *)(rfd->priv);
106     else {
107         p = (struct rset_prox_rfd *) nmem_malloc(ct->nmem,sizeof(*p));
108         rfd->priv = p;
109         p->more = nmem_malloc (ct->nmem,sizeof(*p->more) * ct->no_children);
110         p->buf = nmem_malloc(ct->nmem,sizeof(*p->buf) * ct->no_children);
111         p->terms = nmem_malloc(ct->nmem,sizeof(*p->terms) * ct->no_children);
112         for (i = 0; i < ct->no_children; i++) 
113         {
114             p->buf[i] = nmem_malloc(ct->nmem,ct->keycontrol->key_size);
115             p->terms[i] = 0;
116         }
117         p->rfd = nmem_malloc(ct->nmem,sizeof(*p->rfd) * ct->no_children);
118     }
119     yaz_log(YLOG_DEBUG,"rsprox (%s) open [%p] n=%d", 
120             ct->control->desc, rfd, ct->no_children);
121
122     for (i = 0; i < ct->no_children; i++) {
123         p->rfd[i] = rset_open (ct->children[i], RSETF_READ);
124         p->more[i] = rset_read (p->rfd[i], p->buf[i], &p->terms[i]);
125     }
126     p->hits = 0;
127     return rfd;
128 }
129
130 static void r_close (RSFD rfd)
131 {
132     RSET ct = rfd->rset;
133     struct rset_prox_rfd *p = (struct rset_prox_rfd *)(rfd->priv);
134     
135     int i;
136     for (i = 0; i<ct->no_children; i++)
137         rset_close(p->rfd[i]);
138 }
139
140 static int r_forward(RSFD rfd, void *buf, TERMID *term, const void *untilbuf)
141 {
142     RSET ct = rfd->rset;
143     struct rset_prox_info *info = (struct rset_prox_info *)(ct->priv);
144     struct rset_prox_rfd *p = (struct rset_prox_rfd *)(rfd->priv);
145     const struct rset_key_control *kctrl = ct->keycontrol;
146     int cmp = 0;
147     int i;
148
149     if (untilbuf)
150     {
151         /* it is enough to forward first one. Other will follow. */
152         if ( p->more[0] &&   /* was: cmp >=2 */
153            ((kctrl->cmp)(untilbuf, p->buf[0]) >= rfd->rset->scope) ) 
154             p->more[0] = rset_forward(p->rfd[0], p->buf[0], 
155                                       &p->terms[0], untilbuf);
156     }
157     if (info->ordered && info->relation == 3 && info->exclusion == 0
158         && info->distance == 1)
159     {
160         while (p->more[0]) 
161         {
162             for (i = 1; i < ct->no_children; i++)
163             {
164                 if (!p->more[i]) 
165                 {
166                     p->more[0] = 0; /* saves us a goto out of while loop. */
167                     break;
168                 }
169                 cmp = (*kctrl->cmp) (p->buf[i], p->buf[i-1]);
170                 if (cmp >= rfd->rset->scope )  /* cmp>1 */
171                 {
172                     p->more[i-1] = rset_forward (p->rfd[i-1],
173                                                  p->buf[i-1],
174                                                  &p->terms[i-1],
175                                                  p->buf[i]);
176                     break;
177                 }
178                 else if ( cmp>0 ) /* cmp == 1*/
179                 {
180                     if ((*kctrl->getseq)(p->buf[i-1]) +1 != 
181                         (*kctrl->getseq)(p->buf[i]))
182                     { /* FIXME - We need more flexible multilevel stuff */
183                         p->more[i-1] = rset_read ( p->rfd[i-1], p->buf[i-1],
184                                                    &p->terms[i-1]);
185                         break;
186                     }
187                 }
188                 else
189                 {
190                     p->more[i] = rset_forward (p->rfd[i], 
191                                   p->buf[i], &p->terms[i], p->buf[i-1]);
192                     break;
193                 }
194             }
195             if (i == ct->no_children)
196             {
197                 memcpy (buf, p->buf[0], kctrl->key_size);
198                 if (term)
199                     *term = p->terms[0];
200                 p->more[0] = rset_read (p->rfd[0], p->buf[0], &p->terms[0]);
201                 p->hits++;
202                 return 1;
203             }
204         }
205     }
206     else if (ct->no_children == 2)
207     {
208         while (p->more[0] && p->more[1]) 
209         {
210             int cmp = (*kctrl->cmp)(p->buf[0], p->buf[1]);
211             if ( cmp <= - rfd->rset->scope) /* cmp<-1*/
212                 p->more[0] = rset_forward (p->rfd[0], p->buf[0], 
213                                            &p->terms[0],p->buf[1]);
214             else if ( cmp >= rfd->rset->scope ) /* cmp>1 */
215                 p->more[1] = rset_forward (p->rfd[1], p->buf[1], 
216                                            &p->terms[1],p->buf[0]);
217             else
218             {
219                 zint seqno[500]; /* FIXME - why 500 ?? */
220                 int n = 0;
221                 
222                 seqno[n++] = (*kctrl->getseq)(p->buf[0]);
223                 while ((p->more[0] = rset_read (p->rfd[0],
224                                         p->buf[0], &p->terms[0])))
225                 {
226                     cmp = (*kctrl->cmp)(p->buf[0], p->buf[1]);
227                     if (cmp <= - rfd->rset->scope || cmp >= rfd->rset->scope)
228                         break;
229                     if (n < 500)
230                         seqno[n++] = (*kctrl->getseq)(p->buf[0]);
231                 }
232                 for (i = 0; i<n; i++)
233                 {
234                     zint diff = (*kctrl->getseq)(p->buf[1]) - seqno[i];
235                     int excl = info->exclusion;
236                     if (!info->ordered && diff < 0)
237                         diff = -diff;
238                     switch (info->relation)
239                     {
240                     case 1:      /* < */
241                         if (diff < info->distance && diff >= 0)
242                             excl = !excl;
243                         break;
244                     case 2:      /* <= */
245                         if (diff <= info->distance && diff >= 0)
246                             excl = !excl;
247                         break;
248                     case 3:      /* == */
249                         if (diff == info->distance && diff >= 0)
250                             excl = !excl;
251                         break;
252                     case 4:      /* >= */
253                         if (diff >= info->distance && diff >= 0)
254                             excl = !excl;
255                         break;
256                     case 5:      /* > */
257                         if (diff > info->distance && diff >= 0)
258                             excl = !excl;
259                         break;
260                     case 6:      /* != */
261                         if (diff != info->distance && diff >= 0)
262                             excl = !excl;
263                         break;
264                     }
265                     if (excl)
266                     {
267                         memcpy (buf, p->buf[1], kctrl->key_size);
268                         if (term)
269                             *term = p->terms[1];
270                         p->more[1] = rset_read ( p->rfd[1], p->buf[1],
271                                                  &p->terms[1]);
272                         p->hits++;
273                         return 1;
274                     }
275                 }
276                 p->more[1] = rset_read (p->rfd[1], p->buf[1], &p->terms[1]);
277             }
278         }
279     }
280     return 0;
281 }
282
283
284 static int r_read (RSFD rfd, void *buf, TERMID *term)
285 {
286     return r_forward(rfd, buf, term, 0);
287 }
288
289 static int r_write (RSFD rfd, const void *buf)
290 {
291     yaz_log(YLOG_FATAL, "prox set type is read-only");
292     return -1;
293 }
294
295 static void r_pos (RSFD rfd, double *current, double *total)
296 {
297     RSET ct = rfd->rset;
298     struct rset_prox_rfd *p = (struct rset_prox_rfd *)(rfd->priv);
299     int i;
300     double r = 0.0;
301     double cur, tot = -1.0;
302     double scur = 0.0, stot = 0.0;
303
304     yaz_log(YLOG_DEBUG, "rsprox_pos");
305
306     for (i = 0; i < ct->no_children; i++)
307     {
308         rset_pos(p->rfd[i],  &cur, &tot);
309         if (tot>0) {
310             scur += cur;
311             stot += tot;
312         }
313     }
314     if (tot <0) {  /* nothing found */
315         *current = -1;
316         *total = -1;
317     } else if (tot < 1) { /* most likely tot==0 */
318         *current = 0;
319         *total = 0;
320     } else {
321         r = scur/stot; 
322         *current = (double) p->hits;
323         *total=*current/r ; 
324     }
325     yaz_log(YLOG_DEBUG,"prox_pos: [%d] %0.1f/%0.1f= %0.4f ",
326                     i,*current, *total, r);
327 }
328
329 static void r_get_terms(RSET ct, TERMID *terms, int maxterms, int *curterm)
330 {
331     int i;
332     for (i = 0; i<ct->no_children; i++)
333         rset_getterms(ct->children[i], terms, maxterms, curterm);
334 }
335
336 /*
337  * Local variables:
338  * c-basic-offset: 4
339  * c-file-style: "Stroustrup"
340  * indent-tabs-mode: nil
341  * End:
342  * vim: shiftwidth=4 tabstop=8 expandtab
343  */
344