util/zebramap.c

   1 /*
   2  * Copyright (C) 1994-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zebramap.c,v $
   7  * Revision 1.14  1999-02-19 10:37:40  adam
   8  * Minor fix.
   9  *
  10  * Revision 1.13  1999/02/18 15:01:04  adam
  11  * Structure=key uses register type 0.
  12  *
  13  * Revision 1.12  1999/02/12 13:29:25  adam
  14  * Implemented position-flag for registers.
  15  *
  16  * Revision 1.11  1998/10/13 20:09:19  adam
  17  * Changed call to readconf_line.
  18  *
  19  * Revision 1.10  1998/06/23 15:33:37  adam
  20  * Added feature to specify sort criteria in query (type 7 specifies
  21  * sort flags).
  22  *
  23  * Revision 1.9  1998/04/02 14:35:30  adam
  24  * First version of Zebra that works with compiled ASN.1.
  25  *
  26  * Revision 1.8  1998/03/05 08:42:44  adam
  27  * Minor changes to zebramap data structures. Query mapping rules changed.
  28  *
  29  * Revision 1.7  1998/02/10 12:03:07  adam
  30  * Implemented Sort.
  31  *
  32  * Revision 1.6  1998/01/29 13:36:01  adam
  33  * Structure word-list, free-form-text and document-text all
  34  * trigger ranked search.
  35  *
  36  * Revision 1.5  1997/11/19 10:22:14  adam
  37  * Bug fix (introduced by previous commit).
  38  *
  39  * Revision 1.4  1997/11/18 10:05:08  adam
  40  * Changed character map facility so that admin can specify character
  41  * mapping files for each register type, w, p, etc.
  42  *
  43  * Revision 1.3  1997/11/17 15:35:26  adam
  44  * Bug fix. Relation=relevance wasn't observed.
  45  *
  46  * Revision 1.2  1997/10/31 12:39:30  adam
  47  * Changed log message.
  48  *
  49  * Revision 1.1  1997/10/27 14:33:06  adam
  50  * Moved towards generic character mapping depending on "structure"
  51  * field in abstract syntax file. Fixed a few memory leaks. Fixed
  52  * bug with negative integers when doing searches with relational
  53  * operators.
  54  *
  55  */
  56
  57 #include <assert.h>
  58 #include <ctype.h>
  59
  60 #include <yaz-util.h>
  61 #include <charmap.h>
  62 #include <zebramap.h>
  63
  64 #define ZEBRA_MAP_TYPE_SORT  1
  65 #define ZEBRA_MAP_TYPE_INDEX 2
  66
  67 struct zebra_map {
  68     unsigned reg_id;
  69     int completeness;
  70     int positioned;
  71     int type;
  72     union {
  73         struct {
  74             int dummy;
  75         } index;
  76         struct {
  77             int entry_size;
  78         } sort;
  79     } u;
  80     chrmaptab maptab;
  81     const char *maptab_name;
  82     struct zebra_map *next;
  83 };
  84
  85 struct zebra_maps {
  86     char *tabpath;
  87     NMEM nmem;
  88     struct zebra_map *map_list;
  89     char temp_map_str[2];
  90     const char *temp_map_ptr[2];
  91     struct zebra_map **lookup_array;
  92 };
  93
  94 void zebra_maps_close (ZebraMaps zms)
  95 {
  96     struct zebra_map *zm = zms->map_list;
  97     while (zm)
  98     {
  99         if (zm->maptab)
 100             chrmaptab_destroy (zm->maptab);
 101         zm = zm->next;
 102     }
 103     nmem_destroy (zms->nmem);
 104     xfree (zms);
 105 }
 106
 107 static void zebra_map_read (ZebraMaps zms, const char *name)
 108 {
 109     FILE *f;
 110     char line[512];
 111     char *argv[10];
 112     int argc;
 113     int lineno = 0;
 114     struct zebra_map **zm = 0, *zp;
 115
 116     if (!(f = yaz_path_fopen(zms->tabpath, name, "r")))
 117     {
 118         logf(LOG_WARN|LOG_ERRNO, "%s", name);
 119         return ;
 120     }
 121     while ((argc = readconf_line(f, &lineno, line, 512, argv, 10)))
 122     {
 123         if (!yaz_matchstr (argv[0], "index") && argc == 2)
 124         {
 125             if (!zm)
 126                 zm = &zms->map_list;
 127             else
 128                 zm = &(*zm)->next;
 129             *zm = nmem_malloc (zms->nmem, sizeof(**zm));
 130             (*zm)->reg_id = argv[1][0];
 131             (*zm)->maptab_name = NULL;
 132             (*zm)->maptab = NULL;
 133             (*zm)->type = ZEBRA_MAP_TYPE_INDEX;
 134             (*zm)->completeness = 0;
 135             (*zm)->positioned = 1;
 136         }
 137         else if (!yaz_matchstr (argv[0], "sort") && argc == 2)
 138         {
 139             if (!zm)
 140                 zm = &zms->map_list;
 141             else
 142                 zm = &(*zm)->next;
 143             *zm = nmem_malloc (zms->nmem, sizeof(**zm));
 144             (*zm)->reg_id = argv[1][0];
 145             (*zm)->maptab_name = NULL;
 146             (*zm)->type = ZEBRA_MAP_TYPE_SORT;
 147             (*zm)->u.sort.entry_size = 80;
 148             (*zm)->maptab = NULL;
 149             (*zm)->completeness = 0;
 150             (*zm)->positioned = 0;
 151         }
 152         else if (zm && !yaz_matchstr (argv[0], "charmap") && argc == 2)
 153         {
 154             (*zm)->maptab_name = nmem_strdup (zms->nmem, argv[1]);
 155         }
 156         else if (zm && !yaz_matchstr (argv[0], "completeness") && argc == 2)
 157         {
 158             (*zm)->completeness = atoi (argv[1]);
 159         }
 160         else if (zm && !yaz_matchstr (argv[0], "position") && argc == 2)
 161         {
 162             (*zm)->positioned = atoi (argv[1]);
 163         }
 164         else if (zm && !yaz_matchstr (argv[0], "entrysize") && argc == 2)
 165         {
 166             if ((*zm)->type == ZEBRA_MAP_TYPE_SORT)
 167                 (*zm)->u.sort.entry_size = atoi (argv[1]);
 168         }
 169     }
 170     if (zm)
 171         (*zm)->next = NULL;
 172     fclose (f);
 173
 174     for (zp = zms->map_list; zp; zp = zp->next)
 175         zms->lookup_array[zp->reg_id] = zp;
 176 }
 177
 178 static void zms_map_handle (void *p, const char *name, const char *value)
 179 {
 180     ZebraMaps zms = p;
 181
 182     zebra_map_read (zms, value);
 183 }
 184
 185 ZebraMaps zebra_maps_open (Res res)
 186 {
 187     ZebraMaps zms = xmalloc (sizeof(*zms));
 188     int i;
 189
 190     zms->nmem = nmem_create ();
 191     zms->tabpath = nmem_strdup (zms->nmem, res_get_def (res, "profilePath", "."));
 192     zms->map_list = NULL;
 193
 194     zms->temp_map_str[0] = '\0';
 195     zms->temp_map_str[1] = '\0';
 196
 197     zms->temp_map_ptr[0] = zms->temp_map_str;
 198     zms->temp_map_ptr[1] = NULL;
 199
 200     zms->lookup_array =
 201         nmem_malloc (zms->nmem, sizeof(*zms->lookup_array)*256);
 202     for (i = 0; i<256; i++)
 203         zms->lookup_array[i] = 0;
 204     if (!res || !res_trav (res, "index", zms, zms_map_handle))
 205         zebra_map_read (zms, "default.idx");
 206     return zms;
 207 }
 208
 209 struct zebra_map *zebra_map_get (ZebraMaps zms, unsigned reg_id)
 210 {
 211     return zms->lookup_array[reg_id];
 212 }
 213
 214 chrmaptab zebra_charmap_get (ZebraMaps zms, unsigned reg_id)
 215 {
 216     struct zebra_map *zm = zebra_map_get (zms, reg_id);
 217     if (!zm)
 218     {
 219         zm = nmem_malloc (zms->nmem, sizeof(*zm));
 220         logf (LOG_WARN, "Unknown register type: %c", reg_id);
 221
 222         zm->reg_id = reg_id;
 223         zm->maptab_name = NULL;
 224         zm->maptab = NULL;
 225         zm->type = ZEBRA_MAP_TYPE_INDEX;
 226         zm->completeness = 0;
 227         zm->next = zms->map_list;
 228         zms->map_list = zm->next;
 229
 230         zms->lookup_array[zm->reg_id & 255] = zm;
 231     }
 232     if (!zm->maptab)
 233     {
 234         if (!zm->maptab_name || !yaz_matchstr (zm->maptab_name, "@"))
 235             return NULL;
 236         if (!(zm->maptab = chrmaptab_create (zms->tabpath,
 237                                              zm->maptab_name, 0)))
 238             logf(LOG_WARN, "Failed to read character table %s",
 239                  zm->maptab_name);
 240         else
 241             logf(LOG_DEBUG, "Read character table %s", zm->maptab_name);
 242     }
 243     return zm->maptab;
 244 }
 245
 246 const char **zebra_maps_input (ZebraMaps zms, unsigned reg_id,
 247                                const char **from, int len)
 248 {
 249     chrmaptab maptab;
 250
 251     maptab = zebra_charmap_get (zms, reg_id);
 252     if (maptab)
 253         return chr_map_input(maptab, from, len);
 254
 255     zms->temp_map_str[0] = **from;
 256
 257     (*from)++;
 258     return zms->temp_map_ptr;
 259 }
 260
 261 const char *zebra_maps_output(ZebraMaps zms, unsigned reg_id,
 262                               const char **from)
 263 {
 264     chrmaptab maptab;
 265     unsigned char i = (unsigned char) **from;
 266     static char buf[2] = {0,0};
 267
 268     maptab = zebra_charmap_get (zms, reg_id);
 269     if (maptab)
 270         return chr_map_output (maptab, from, 1);
 271     (*from)++;
 272     buf[0] = i;
 273     return buf;
 274 }
 275
 276
 277 /* ------------------------------------ */
 278
 279 typedef struct {
 280     int type;
 281     int major;
 282     int minor;
 283     Z_AttributeElement **attributeList;
 284     int num_attributes;
 285 } AttrType;
 286
 287 static int attr_find (AttrType *src, oid_value *attributeSetP)
 288 {
 289     while (src->major < src->num_attributes)
 290     {
 291         Z_AttributeElement *element;
 292
 293         element = src->attributeList[src->major];
 294         if (src->type == *element->attributeType)
 295         {
 296             switch (element->which)
 297             {
 298             case Z_AttributeValue_numeric:
 299                 ++(src->major);
 300                 if (element->attributeSet && attributeSetP)
 301                 {
 302                     oident *attrset;
 303
 304                     attrset = oid_getentbyoid (element->attributeSet);
 305                     *attributeSetP = attrset->value;
 306                 }
 307                 return *element->value.numeric;
 308                 break;
 309             case Z_AttributeValue_complex:
 310                 if (src->minor >= element->value.complex->num_list ||
 311                     element->value.complex->list[src->minor]->which !=
 312                     Z_StringOrNumeric_numeric)
 313                     break;
 314                 ++(src->minor);
 315                 if (element->attributeSet && attributeSetP)
 316                 {
 317                     oident *attrset;
 318
 319                     attrset = oid_getentbyoid (element->attributeSet);
 320                     *attributeSetP = attrset->value;
 321                 }
 322                 return *element->value.complex->list[src->minor-1]->u.numeric;
 323             default:
 324                 assert (0);
 325             }
 326         }
 327         ++(src->major);
 328     }
 329     return -1;
 330 }
 331
 332 static void attr_init_APT (AttrType *src, Z_AttributesPlusTerm *zapt, int type)
 333 {
 334 #ifdef ASN_COMPILED
 335     src->attributeList = zapt->attributes->attributes;
 336     src->num_attributes = zapt->attributes->num_attributes;
 337 #else
 338     src->attributeList = zapt->attributeList;
 339     src->num_attributes = zapt->num_attributes;
 340 #endif
 341     src->type = type;
 342     src->major = 0;
 343     src->minor = 0;
 344 }
 345
 346 static void attr_init_AttrList (AttrType *src, Z_AttributeList *list, int type)
 347 {
 348     src->attributeList = list->attributes;
 349     src->num_attributes = list->num_attributes;
 350     src->type = type;
 351     src->major = 0;
 352     src->minor = 0;
 353 }
 354
 355 /* ------------------------------------ */
 356
 357 int zebra_maps_is_complete (ZebraMaps zms, unsigned reg_id)
 358 {
 359     struct zebra_map *zm = zebra_map_get (zms, reg_id);
 360     if (zm)
 361         return zm->completeness;
 362     return 0;
 363 }
 364
 365 int zebra_maps_is_positioned (ZebraMaps zms, unsigned reg_id)
 366 {
 367     struct zebra_map *zm = zebra_map_get (zms, reg_id);
 368     if (zm)
 369         return zm->positioned;
 370     return 0;
 371 }
 372
 373 int zebra_maps_is_sort (ZebraMaps zms, unsigned reg_id)
 374 {
 375     struct zebra_map *zm = zebra_map_get (zms, reg_id);
 376     if (zm)
 377         return zm->type == ZEBRA_MAP_TYPE_SORT;
 378     return 0;
 379 }
 380
 381 int zebra_maps_sort (ZebraMaps zms, Z_SortAttributes *sortAttributes)
 382 {
 383     AttrType use;
 384     attr_init_AttrList (&use, sortAttributes->list, 1);
 385
 386     return attr_find (&use, NULL);
 387 }
 388
 389 int zebra_maps_attr (ZebraMaps zms, Z_AttributesPlusTerm *zapt,
 390                      unsigned *reg_id, char **search_type, char **rank_type,
 391                      int *complete_flag, int *sort_flag)
 392 {
 393     AttrType completeness;
 394     AttrType structure;
 395     AttrType relation;
 396     AttrType sort_relation;
 397     int completeness_value;
 398     int structure_value;
 399     int relation_value;
 400     int sort_relation_value;
 401
 402     attr_init_APT (&structure, zapt, 4);
 403     attr_init_APT (&completeness, zapt, 6);
 404     attr_init_APT (&relation, zapt, 2);
 405     attr_init_APT (&sort_relation, zapt, 7);
 406
 407     completeness_value = attr_find (&completeness, NULL);
 408     structure_value = attr_find (&structure, NULL);
 409     relation_value = attr_find (&relation, NULL);
 410     sort_relation_value = attr_find (&sort_relation, NULL);
 411
 412     if (completeness_value == 2 || completeness_value == 3)
 413         *complete_flag = 1;
 414     else
 415         *complete_flag = 0;
 416     *reg_id = 0;
 417
 418     *sort_flag = (sort_relation_value > 0) ? 1 : 0;
 419     *search_type = "phrase";
 420     *rank_type = "void";
 421     if (relation_value == 102)
 422         *rank_type = "rank";
 423
 424     if (*complete_flag)
 425         *reg_id = 'p';
 426     else
 427         *reg_id = 'w';
 428     switch (structure_value)
 429     {
 430     case 6:   /* word list */
 431         *search_type = "and-list";
 432         break;
 433     case 105: /* free-form-text */
 434         *search_type = "or-list";
 435         break;
 436     case 106: /* document-text */
 437         *search_type = "or-list";
 438         break;
 439     case -1:
 440     case 1:   /* phrase */
 441     case 2:   /* word */
 442     case 108: /* string */
 443         *search_type = "phrase";
 444         break;
 445     case 107: /* local-number */
 446         *search_type = "local";
 447         *reg_id = 0;
 448         break;
 449     case 109: /* numeric string */
 450         *reg_id = 'n';
 451         *search_type = "numeric";
 452         break;
 453     case 104: /* urx */
 454         *reg_id = 'u';
 455         *search_type = "phrase";
 456         break;
 457     case 3:   /* key */
 458         *reg_id = '0';
 459         *search_type = "phrase";
 460         break;
 461     default:
 462         return -1;
 463     }
 464     return 0;
 465 }