dict/dicttest.c

   1 /* This file is part of the Zebra server.
   2    Copyright (C) 1994-2010 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