Happy new year.
[idzebra-moved-to-github.git] / index / rpnscan.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 1994-2011 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 <assert.h>
22 #ifdef WIN32
23 #include <io.h>
24 #endif
25 #if HAVE_UNISTD_H
26 #include <unistd.h>
27 #endif
28 #include <ctype.h>
29
30 #include <yaz/diagbib1.h>
31 #include "index.h"
32 #include <zebra_xpath.h>
33 #include <yaz/wrbuf.h>
34 #include <attrfind.h>
35 #include <charmap.h>
36 #include <rset.h>
37 #include <yaz/oid_db.h>
38
39 #define RPN_MAX_ORDS 32
40
41 /* convert APT SCAN term to internal cmap */
42 static ZEBRA_RES trans_scan_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
43                                  char *termz, zebra_map_t zm)
44 {
45     char term_utf8[IT_MAX_WORD];
46
47     if (zapt_term_to_utf8(zh, zapt, term_utf8) == ZEBRA_FAIL)
48         return ZEBRA_FAIL;    /* error */
49     else if (zebra_maps_is_icu(zm))
50     {
51         const char *res_buf;
52         size_t res_len;
53         zebra_map_tokenize_start(zm, term_utf8, strlen(term_utf8));
54         
55         if (zebra_map_tokenize_next(zm, &res_buf, &res_len, 0, 0))
56         {
57             memcpy(termz, res_buf, res_len);
58             termz[res_len] = '\0';
59         }
60         else
61             termz[0] = '\0';
62     }
63     else
64     {
65         const char **map;
66         const char *cp = (const char *) term_utf8;
67         const char *cp_end = cp + strlen(cp);
68         const char *src;
69         int i = 0;
70         const char *space_map = NULL;
71         int len;
72             
73         while ((len = (cp_end - cp)) > 0)
74         {
75             map = zebra_maps_input(zm, &cp, len, 0);
76             if (**map == *CHR_SPACE)
77                 space_map = *map;
78             else
79             {
80                 if (i && space_map)
81                     for (src = space_map; *src; src++)
82                         termz[i++] = *src;
83                 space_map = NULL;
84                 for (src = *map; *src; src++)
85                     termz[i++] = *src;
86             }
87         }
88         termz[i] = '\0';
89     }
90     return ZEBRA_OK;
91 }
92
93 static void get_first_snippet_from_rset(ZebraHandle zh, 
94                                         RSET rset, zebra_snippets *snippets, 
95                                         zint *sysno)
96 {
97     struct it_key key;
98     RSFD rfd;
99     TERMID termid;
100     size_t sysno_mem_index = 0;
101
102     if (zh->m_staticrank)
103         sysno_mem_index = 1;
104
105     yaz_log(YLOG_DEBUG, "get_first_snippet_from_rset");
106
107     rfd = rset_open(rset, RSETF_READ);
108     *sysno = 0;
109     while (rset_read(rfd, &key, &termid))
110     {
111         if (key.mem[sysno_mem_index] != *sysno)
112         {
113             if (*sysno)
114                 break;
115             *sysno = key.mem[sysno_mem_index];
116         }
117         if (termid)
118         {
119             struct ord_list *ol;
120             for (ol = termid->ol; ol; ol = ol->next)
121             {
122                 zebra_snippets_append(snippets, key.mem[key.len-1], 0,
123                                       ol->ord, termid->name);
124             }
125         }
126     }
127     rset_close(rfd);
128 }
129
130 struct scan2_info_entry {
131     WRBUF term;
132     char prefix[20];
133     ISAM_P isam_p;
134     int pos_to_save;
135     int ord;
136 };
137
138 static int scan_handle2(char *name, const char *info, int pos, void *client)
139 {
140     int len_prefix;
141     struct scan2_info_entry *scan_info = (struct scan2_info_entry *) client;
142
143     if (scan_info->pos_to_save != pos)
144         return 0;
145
146     len_prefix = strlen(scan_info->prefix);
147     if (memcmp(name, scan_info->prefix, len_prefix))
148         return 1;
149
150     /* skip special terms such as first-in-field specials */
151     if (name[len_prefix] < CHR_BASE_CHAR)
152         return 1;
153
154     wrbuf_rewind(scan_info->term);
155     wrbuf_puts(scan_info->term, name+len_prefix);
156
157     assert(*info == sizeof(ISAM_P));
158     memcpy(&scan_info->isam_p, info+1, sizeof(ISAM_P));
159     return 0;
160 }
161
162
163 static int scan_save_set(ZebraHandle zh, ODR stream, NMEM nmem,
164                          struct rset_key_control *kc,
165                          Z_AttributesPlusTerm *zapt,
166                          RSET limit_set,
167                          const char *term, 
168                          const char *index_type,
169                          struct scan2_info_entry *ar, int ord_no,
170                          ZebraScanEntry *glist, int pos)
171 {
172     int i;
173     RSET rset = 0;
174     zint approx_limit = zh->approx_limit;
175     AttrType global_hits_limit_attr;
176     int l;
177     attr_init_APT(&global_hits_limit_attr, zapt, 12);
178             
179     l = attr_find(&global_hits_limit_attr, NULL);
180     if (l != -1)
181         approx_limit = l;
182     
183     for (i = 0; i < ord_no; i++)
184     {
185         if (ar[i].isam_p && strcmp(wrbuf_cstr(ar[i].term), term) == 0)
186         {
187             struct ord_list *ol = ord_list_create(nmem);
188             RSET rset_t;
189
190             ol = ord_list_append(nmem, ol, ar[i].ord);
191
192             assert(ol);
193             rset_t = rset_trunc(
194                     zh, &ar[i].isam_p, 1,
195                     wrbuf_buf(ar[i].term), wrbuf_len(ar[i].term),
196                     NULL, 1, zapt->term->which, nmem, 
197                     kc, kc->scope, ol, index_type, 
198                     0 /* hits_limit_value */,
199                     0 /* term_ref_id_str */);
200             if (!rset)
201                 rset = rset_t;
202             else
203             {
204                 RSET rsets[2];
205                 
206                 rsets[0] = rset;
207                 rsets[1] = rset_t;
208                 rset = rset_create_or(nmem, kc, kc->scope, 0 /* termid */,
209                                       2, rsets);
210             }
211             ar[i].isam_p = 0;
212         }
213     }
214     if (rset)
215     {
216         zint count;
217         /* merge with limit_set if given */
218         if (limit_set)
219         {
220             RSET rsets[2];
221             rsets[0] = rset;
222             rsets[1] = rset_dup(limit_set);
223             
224             rset = rset_create_and(nmem, kc, kc->scope, 2, rsets);
225         }
226         /* count it */
227         zebra_count_set(zh, rset, &count, approx_limit);
228
229         if (pos != -1)
230         {
231             zint sysno;
232             zebra_snippets *hit_snippets = zebra_snippets_create();
233
234             glist[pos].term = 0;
235             glist[pos].display_term = 0;
236             
237             get_first_snippet_from_rset(zh, rset, hit_snippets, &sysno);
238             if (sysno)
239             {
240                 zebra_snippets *rec_snippets = zebra_snippets_create();
241                 int code = zebra_get_rec_snippets(zh, sysno, rec_snippets);
242                 if (code == 0)
243                 {
244                     const struct zebra_snippet_word *w = 
245                         zebra_snippets_lookup(rec_snippets, hit_snippets);
246                     if (w)
247                     {
248                         glist[pos].display_term = odr_strdup(stream, w->term);
249                     }
250                     else
251                     {
252                         yaz_log(YLOG_WARN, "zebra_snippets_lookup failed for pos=%d", pos);
253                     }
254                 }
255                 zebra_snippets_destroy(rec_snippets);
256             }
257             if (zebra_term_untrans_iconv(zh, stream->mem, index_type,
258                                          &glist[pos].term, term))
259             {
260                 /* failed.. use display_term instead (which could be 0) */
261                 glist[pos].term = glist[pos].display_term;
262             }
263
264             if (!glist[pos].term)
265             {
266                 yaz_log(YLOG_WARN, "Could not generate scan term for pos=%d",
267                         pos);
268                 glist[pos].term = "None";
269             }
270             glist[pos].occurrences = count;
271             zebra_snippets_destroy(hit_snippets);
272         }
273         rset_delete(rset);
274         if (count > 0)
275             return 1;
276         else
277             return 0;
278     }
279     return 0;
280 }
281
282 static ZEBRA_RES rpn_scan_norm(ZebraHandle zh, ODR stream, NMEM nmem,
283                                struct rset_key_control *kc,
284                                Z_AttributesPlusTerm *zapt,
285                                int *position, int *num_entries, 
286                                ZebraScanEntry **list,
287                                int *is_partial, RSET limit_set,
288                                const char *index_type,
289                                int ord_no, int *ords)
290 {
291     struct scan2_info_entry *ar = nmem_malloc(nmem, sizeof(*ar) * ord_no);
292     struct rpn_char_map_info rcmi;
293     zebra_map_t zm = zebra_map_get_or_add(zh->reg->zebra_maps, index_type);
294     int i, dif;
295     int after_pos;
296     int pos = 0;
297
298     ZebraScanEntry *glist = (ZebraScanEntry *)
299         odr_malloc(stream, *num_entries * sizeof(*glist));
300
301     *is_partial = 0;
302     if (*position > *num_entries+1)
303     {
304         *is_partial = 1;
305         *position = 1;
306         *num_entries = 0;
307         return ZEBRA_OK;
308     }
309     rpn_char_map_prepare(zh->reg, zm, &rcmi);
310
311     for (i = 0; i < ord_no; i++)
312         ar[i].term = wrbuf_alloc();
313
314     for (i = 0; i < ord_no; i++)
315     {
316         char termz[IT_MAX_WORD+20];
317         int prefix_len = 0;
318         
319         prefix_len = key_SU_encode(ords[i], termz);
320         termz[prefix_len] = 0;
321         strcpy(ar[i].prefix, termz);
322         
323         if (trans_scan_term(zh, zapt, termz+prefix_len, zm) == 
324             ZEBRA_FAIL)
325         {
326             for (i = 0; i < ord_no; i++)
327                 wrbuf_destroy(ar[i].term);
328             return ZEBRA_FAIL;
329         }
330         wrbuf_rewind(ar[i].term);
331         wrbuf_puts(ar[i].term, termz + prefix_len);
332         ar[i].isam_p = 0;
333         ar[i].ord = ords[i];
334     }
335     /** deal with terms before position .. */
336     /* the glist index starts at zero (unlike scan positions */
337     for (pos = *position-2; pos >= 0; )
338     {
339         const char *hi = 0;
340
341         /* scan on all maximum terms */
342         for (i = 0; i < ord_no; i++)
343         {
344             if (ar[i].isam_p == 0)
345             {
346                 char termz[IT_MAX_WORD+20];
347                 int before = 1;
348                 int after = 0;
349
350                 ar[i].pos_to_save = -1;
351
352                 strcpy(termz, ar[i].prefix);
353                 strcat(termz, wrbuf_cstr(ar[i].term));
354                 dict_scan(zh->reg->dict, termz, &before, &after,
355                           ar+i, scan_handle2);
356             }
357         }
358         /* get maximum after scan */
359         for (i = 0; i < ord_no; i++)
360         {
361             if (ar[i].isam_p 
362                 && (hi == 0 || strcmp(wrbuf_cstr(ar[i].term), hi) > 0))
363                 hi = wrbuf_cstr(ar[i].term);
364         }
365         if (!hi)
366             break;
367         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, hi,
368                           index_type, ar, ord_no, glist,
369                           (pos >= 0 && pos < *num_entries) ? pos : -1))
370             --pos;
371     }
372     /* see if we got all terms before.. */
373     dif = 1 + pos;
374     if (dif > 0)
375     {
376         /* did not get all terms; adjust the real position and reduce
377            number of entries */
378         yaz_log(YLOG_LOG, "before terms dif=%d", dif);
379         glist = glist + dif;
380         *num_entries -= dif;
381         *position -= dif;
382         *is_partial = 1;
383     }
384     for (i = 0; i < ord_no; i++)
385     {
386         char termz[IT_MAX_WORD+20];
387         int prefix_len = 0;
388         
389         prefix_len = key_SU_encode(ords[i], termz);
390         termz[prefix_len] = 0;
391         strcpy(ar[i].prefix, termz);
392         
393         if (trans_scan_term(zh, zapt, termz+prefix_len, zm) == 
394             ZEBRA_FAIL)
395             return ZEBRA_FAIL;
396         wrbuf_rewind(ar[i].term);
397         wrbuf_puts(ar[i].term, termz + prefix_len);
398         ar[i].isam_p = 0;
399         ar[i].ord = ords[i];
400     }
401
402     after_pos = 1;  /* immediate term first.. */
403     for (pos = *position-1; pos < *num_entries; )
404     {
405         const char *lo = 0;
406
407         /* scan on all minimum terms */
408         for (i = 0; i < ord_no; i++)
409         {
410             if (ar[i].isam_p == 0)
411             {
412                 char termz[IT_MAX_WORD+20];
413                 int before = 0;
414                 int after = after_pos;
415
416                 ar[i].pos_to_save = 1;
417
418                 strcpy(termz, ar[i].prefix);
419                 strcat(termz, wrbuf_cstr(ar[i].term));
420                 dict_scan(zh->reg->dict, termz, &before, &after,
421                           ar+i, scan_handle2);
422             }
423         }
424         after_pos = 2;  /* next round we grab following term */
425
426         /* get minimum after scan */
427         for (i = 0; i < ord_no; i++)
428         {
429             if (ar[i].isam_p 
430                 && (lo == 0 || strcmp(wrbuf_cstr(ar[i].term), lo) < 0))
431                 lo = wrbuf_cstr(ar[i].term);
432         }
433         if (!lo)
434             break;
435         if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, lo,
436                           index_type, ar, ord_no, glist,
437                           (pos >= 0 && pos < *num_entries) ? pos : -1))
438             pos++;
439
440     }
441     if (pos != *num_entries)
442     {
443         if (pos >= 0)
444             *num_entries = pos;
445         else
446             *num_entries = 0;
447         *is_partial = 1;
448     }
449
450     *list = glist;
451
452     for (i = 0; i < ord_no; i++)
453         wrbuf_destroy(ar[i].term);
454
455     return ZEBRA_OK;
456 }
457
458 struct scan1_info_entry {
459     char *term;
460     ISAM_P isam_p;
461 };
462
463 struct scan_info {
464     struct scan1_info_entry *list;
465     ODR odr;
466     int before, after;
467     char prefix[20];
468 };
469
470 ZEBRA_RES rpn_scan(ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
471                    const Odr_oid *attributeset,
472                    int num_bases, char **basenames,
473                    int *position, int *num_entries, ZebraScanEntry **list,
474                    int *is_partial, const char *set_name)
475 {
476     int base_no;
477     int ords[RPN_MAX_ORDS], ord_no = 0;
478
479     const char *index_type;
480     char *search_type = NULL;
481     char rank_type[128];
482     int complete_flag;
483     int sort_flag;
484     NMEM nmem;
485     ZEBRA_RES res;
486     struct rset_key_control *kc = 0;
487     RSET limit_set = 0;
488
489     *list = 0;
490     *is_partial = 0;
491
492     if (!attributeset)
493         attributeset = yaz_oid_attset_bib_1;
494
495     if (!set_name)
496     {
497         /* see if there is a @attr 8=set */
498         AttrType termset;
499         int termset_value_numeric;
500         const char *termset_value_string = 0;
501         attr_init_APT(&termset, zapt, 8);
502         termset_value_numeric =
503             attr_find_ex(&termset, NULL, &termset_value_string);
504         if (termset_value_numeric != -1)
505         {
506             if (termset_value_numeric != -2)
507             {
508                 char resname[32];
509                 sprintf(resname, "%d", termset_value_numeric);
510                 set_name = odr_strdup(stream, resname); 
511             }
512             else
513                 set_name = odr_strdup(stream, termset_value_string);
514         }
515     }
516
517     if (set_name)
518     {
519         limit_set = resultSetRef(zh, set_name);
520         
521         if (!limit_set)
522         {
523             zebra_setError(zh, 
524                            YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
525                            set_name);
526             return ZEBRA_FAIL;
527         }
528     }
529
530     yaz_log(YLOG_DEBUG, "position = %d, num = %d",
531             *position, *num_entries);
532         
533     if (zebra_maps_attr(zh->reg->zebra_maps, zapt, &index_type, &search_type,
534                         rank_type, &complete_flag, &sort_flag))
535     {
536         *num_entries = 0;
537         zebra_setError(zh, YAZ_BIB1_UNSUPP_ATTRIBUTE_TYPE, 0);
538         return ZEBRA_FAIL;
539     }
540     if (num_bases > RPN_MAX_ORDS)
541     {
542         zebra_setError(zh, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
543         return ZEBRA_FAIL;
544     }
545     for (base_no = 0; base_no < num_bases; base_no++)
546     {
547         int ord;
548
549         if (zebraExplain_curDatabase(zh->reg->zei, basenames[base_no]))
550         {
551             zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
552                            basenames[base_no]);
553             *num_entries = 0;
554             return ZEBRA_FAIL;
555         }
556         if (zebra_apt_get_ord(zh, zapt, index_type, 0, attributeset, &ord) 
557             != ZEBRA_OK)
558             continue;
559         ords[ord_no++] = ord;
560     }
561     if (ord_no == 0)
562     {
563         *num_entries = 0; /* zebra_apt_get_ord should set error reason */
564         return ZEBRA_FAIL;
565     }
566     if (*num_entries < 1)
567     {
568         *num_entries = 0;
569         return ZEBRA_OK;
570     }
571     nmem = nmem_create();
572     kc = zebra_key_control_create(zh);
573
574     res = rpn_scan_norm(zh, stream, nmem, kc, zapt, position, num_entries,
575                         list, is_partial, limit_set,
576                         index_type, ord_no, ords);
577     nmem_destroy(nmem);
578     (*kc->dec)(kc);
579     return res;
580 }
581
582 /*
583  * Local variables:
584  * c-basic-offset: 4
585  * c-file-style: "Stroustrup"
586  * indent-tabs-mode: nil
587  * End:
588  * vim: shiftwidth=4 tabstop=8 expandtab
589  */
590