Updated footer comment
[idzebra-moved-to-github.git] / dict / dicttest.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 <stdlib.h>
21 #include <string.h>
22 #include <stdio.h>
23 #include <ctype.h>
24
25 #include <idzebra/dict.h>
26 #include <idzebra/util.h>
27 #include <idzebra/res.h>
28 #include <yaz/yaz-util.h>
29
30 char *prog;
31 static Dict dict;
32
33 static int look_hits;
34
35 static int grep_handler (char *name, const char *info, void *client)
36 {
37     look_hits++;
38     printf ("%s\n", name);
39     return 0;
40 }
41
42 static int scan_handler (char *name, const char *info, int pos, void *client)
43 {
44     printf ("%s\n", name);
45     return 0;
46 }
47
48 int main (int argc, char **argv)
49 {
50     Res my_resource = 0;
51     BFiles bfs;
52     const char *name = NULL;
53     const char *inputfile = NULL;
54     const char *config = NULL;
55     const char *delete_term = NULL;
56     int scan_the_thing = 0;
57     int do_delete = 0;
58     int range = -1;
59     int srange = 0;
60     int rw = 0;
61     int infosize = 4;
62     int cache = 10;
63     int ret;
64     int unique = 0;
65     char *grep_pattern = NULL;
66     char *arg;
67     int no_of_iterations = 0;
68     int no_of_new = 0, no_of_same = 0, no_of_change = 0;
69     int no_of_hits = 0, no_of_misses = 0, no_not_found = 0, no_of_deleted = 0;
70     int max_pos;
71     
72     prog = argv[0];
73     if (argc < 2)
74     {
75         fprintf (stderr, "usage:\n "
76                  " %s [-d] [-D t] [-S] [-r n] [-p n] [-u] [-g pat] [-s n] "
77                  "[-v n] [-i f] [-w] [-c n] config file\n\n",
78                  prog);
79         fprintf (stderr, "  -d      delete instead of insert\n");
80         fprintf (stderr, "  -D t    delete subtree instead of insert\n");
81         fprintf (stderr, "  -r n    set regular match range\n");
82         fprintf (stderr, "  -p n    set regular match start range\n");
83         fprintf (stderr, "  -u      report if keys change during insert\n");
84         fprintf (stderr, "  -g p    try pattern n (see -r)\n");
85         fprintf (stderr, "  -s n    set info size to n (instead of 4)\n");
86         fprintf (stderr, "  -v n    set logging level\n");
87         fprintf (stderr, "  -i f    read file with words\n");
88         fprintf (stderr, "  -w      insert/delete instead of lookup\n");
89         fprintf (stderr, "  -c n    cache size (number of pages)\n");
90         fprintf (stderr, "  -S      scan the dictionary\n");
91         exit (1);
92     }
93     while ((ret = options ("D:Sdr:p:ug:s:v:i:wc:", argv, argc, &arg)) != -2)
94     {
95         if (ret == 0)
96         {
97             if (!config)
98                 config = arg;
99             else if (!name)
100                 name = arg;
101             else
102             {
103                 yaz_log (YLOG_FATAL, "too many files specified\n");
104                 exit (1);
105             }
106         }
107         else if (ret == 'D')
108         {
109             delete_term = arg;
110         }
111         else if (ret == 'd')
112             do_delete = 1;
113         else if (ret == 'g')
114         {
115             grep_pattern = arg;
116         }
117         else if (ret == 'r')
118         {
119             range = atoi (arg);
120         }
121         else if (ret == 'p')
122         {
123             srange = atoi (arg);
124         }
125         else if (ret == 'u')
126         {
127             unique = 1;
128         }
129         else if (ret == 'c')
130         {
131             cache = atoi(arg);
132             if (cache<2)
133                 cache = 2;
134         }
135         else if (ret == 'w')
136             rw = 1;
137         else if (ret == 'i')
138             inputfile = arg;
139         else if (ret == 'S')
140             scan_the_thing = 1;
141         else if (ret == 's')
142         {
143             infosize = atoi(arg);
144         }
145         else if (ret == 'v')
146         {
147             yaz_log_init (yaz_log_mask_str(arg), prog, NULL);
148         }
149         else
150         {
151             yaz_log (YLOG_FATAL, "Unknown option '-%s'", arg);
152             exit (1);
153         }
154     }
155     if (!config || !name)
156     {
157         yaz_log (YLOG_FATAL, "no config and/or dictionary specified");
158         exit (1);
159     }
160     my_resource = res_open(0, 0);
161     if (!my_resource)
162     {
163         yaz_log (YLOG_FATAL, "cannot open resource `%s'", config);
164         exit (1);
165     }
166     res_read_file(my_resource, config);
167
168     bfs = bfs_create (res_get(my_resource, "register"), 0);
169     if (!bfs)
170     {
171         yaz_log (YLOG_FATAL, "bfs_create fail");
172         exit (1);
173     }
174     dict = dict_open (bfs, name, cache, rw, 0, 4096);
175     if (!dict)
176     {
177         yaz_log (YLOG_FATAL, "dict_open fail of `%s'", name);
178         exit (1);
179     }
180     if (inputfile)
181     {
182         FILE *ipf;
183         char ipf_buf[1024];
184         int line = 1;
185         char infobytes[120];
186         memset (infobytes, 0, 120);
187
188         if (!(ipf = fopen(inputfile, "r")))
189         {
190             yaz_log (YLOG_FATAL|YLOG_ERRNO, "cannot open %s", inputfile);
191             exit (1);
192         }
193         
194         while (fgets (ipf_buf, 1023, ipf))
195         {
196             char *ipf_ptr = ipf_buf;
197             sprintf (infobytes, "%d", line);
198             for (;*ipf_ptr && *ipf_ptr != '\n';ipf_ptr++)
199             {
200                 if (isalpha(*ipf_ptr) || *ipf_ptr == '_')
201                 {
202                     int i = 1;
203                     while (ipf_ptr[i] && (isalnum(ipf_ptr[i]) ||
204                                           ipf_ptr[i] == '_'))
205                         i++;
206                     if (ipf_ptr[i])
207                         ipf_ptr[i++] = '\0';
208                     if (rw)
209                     {
210                         if (do_delete)
211                             switch (dict_delete (dict, ipf_ptr))
212                             {
213                             case 0:
214                                 no_not_found++;
215                                 break;
216                             case 1:
217                                 no_of_deleted++;
218                             }
219                         else
220                             switch(dict_insert (dict, ipf_ptr,
221                                                 infosize, infobytes))
222                             {
223                             case 0:
224                                 no_of_new++;
225                                 break;
226                             case 1:
227                                 no_of_change++;
228                                 if (unique)
229                                     yaz_log (YLOG_LOG, "%s change\n", ipf_ptr);
230                                 break;
231                             case 2:
232                                 if (unique)
233                                     yaz_log (YLOG_LOG, "%s duplicate\n", ipf_ptr);
234                                 no_of_same++;
235                                 break;
236                             }
237                     }
238                     else if(range < 0)
239                     {
240                         char *cp;
241
242                         cp = dict_lookup (dict, ipf_ptr);
243                         if (cp && *cp)
244                             no_of_hits++;
245                         else
246                             no_of_misses++;
247                     }
248                     else
249                     {
250                         look_hits = 0;
251                         dict_lookup_grep (dict, ipf_ptr, range, NULL,
252                                           &max_pos, srange, grep_handler);
253                         if (look_hits)
254                             no_of_hits++;
255                         else
256                             no_of_misses++;
257                     }
258                     ++no_of_iterations;
259                     if ((no_of_iterations % 10000) == 0)
260                     {
261                         printf ("."); fflush(stdout);
262                     }
263                     ipf_ptr += (i-1);
264                 }
265             }
266             ++line;
267         }
268         fclose (ipf);
269     }
270     if (rw && delete_term)
271     {
272         yaz_log (YLOG_LOG, "dict_delete_subtree %s", delete_term);
273         dict_delete_subtree (dict, delete_term, 0, 0);
274     }
275     if (grep_pattern)
276     {
277         if (range < 0)
278             range = 0;
279         yaz_log (YLOG_LOG, "Grepping '%s'", grep_pattern);
280         dict_lookup_grep (dict, grep_pattern, range, NULL, &max_pos,
281                           srange, grep_handler);
282     }
283     if (rw)
284     {
285         yaz_log (YLOG_LOG, "Iterations.... %d", no_of_iterations);            
286         if (do_delete)
287         {
288             yaz_log (YLOG_LOG, "No of deleted. %d", no_of_deleted);
289             yaz_log (YLOG_LOG, "No not found.. %d", no_not_found);
290         }
291         else
292         {
293             yaz_log (YLOG_LOG, "No of new..... %d", no_of_new);
294             yaz_log (YLOG_LOG, "No of change.. %d", no_of_change);
295         }
296     }
297     else
298     {
299         yaz_log (YLOG_LOG, "Lookups....... %d", no_of_iterations);
300         yaz_log (YLOG_LOG, "No of hits.... %d", no_of_hits);
301         yaz_log (YLOG_LOG, "No of misses.. %d", no_of_misses);
302     }
303     if (scan_the_thing)
304     {
305         char term_dict[1024];
306         
307         int before = 1000000;
308         int after = 1000000;
309         yaz_log (YLOG_LOG, "dict_scan");
310         term_dict[0] = 1;
311         term_dict[1] = 0;
312         dict_scan (dict, term_dict, &before, &after, 0, scan_handler);
313     }
314     dict_close (dict);
315     bfs_destroy (bfs);
316     res_close (my_resource);
317     return 0;
318 }
319 /*
320  * Local variables:
321  * c-basic-offset: 4
322  * c-file-style: "Stroustrup"
323  * indent-tabs-mode: nil
324  * End:
325  * vim: shiftwidth=4 tabstop=8 expandtab
326  */
327