isam/isam.c

   1 /*
   2  * Copyright (C) 1994-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: isam.c,v $
   7  * Revision 1.25  1999-02-02 14:51:16  adam
   8  * Updated WIN32 code specific sections. Changed header.
   9  *
  10  * Revision 1.24  1997/10/27 14:25:39  adam
  11  * Fixed memory leaks.
  12  *
  13  * Revision 1.23  1997/09/17 12:19:20  adam
  14  * Zebra version corresponds to YAZ version 1.4.
  15  * Changed Zebra server so that it doesn't depend on global common_resource.
  16  *
  17  * Revision 1.22  1996/10/29 13:56:53  adam
  18  * Include of zebrautl.h instead of alexutil.h.
  19  *
  20  * Revision 1.21  1996/03/29 14:11:47  quinn
  21  * Change to is_merge
  22  *
  23  * Revision 1.20  1996/03/19  13:14:57  quinn
  24  * Moved an xfree()
  25  *
  26  * Revision 1.19  1996/02/10  12:20:56  quinn
  27  * *** empty log message ***
  28  *
  29  * Revision 1.18  1996/02/06  10:19:56  quinn
  30  * Attempt at fixing bug. Not all blocks were read before they were unlinked
  31  * prior to a remap operation.
  32  *
  33  * Revision 1.17  1995/12/06  15:48:44  quinn
  34  * Fixed update-problem.
  35  *
  36  * Revision 1.16  1995/12/06  14:48:26  quinn
  37  * Fixed some strange bugs.
  38  *
  39  * Revision 1.15  1995/12/06  09:59:45  quinn
  40  * Fixed memory-consumption bug in memory.c
  41  * Added more blocksizes to the default ISAM configuration.
  42  *
  43  * Revision 1.14  1995/11/24  17:26:19  quinn
  44  * Mostly about making some ISAM stuff in the config file optional.
  45  *
  46  * Revision 1.13  1995/10/17  18:03:15  adam
  47  * Commented out qsort in is_merge.
  48  *
  49  * Revision 1.12  1995/09/06  16:11:41  adam
  50  * Keysize parameter to is_open (if non-zero).
  51  *
  52  * Revision 1.11  1995/09/04  12:33:46  adam
  53  * Various cleanup. YAZ util used instead.
  54  *
  55  * Revision 1.10  1994/09/28  16:58:32  quinn
  56  * Small mod.
  57  *
  58  * Revision 1.9  1994/09/28  12:56:15  quinn
  59  * Added access functions (ISPT)
  60  *
  61  * Revision 1.8  1994/09/28  12:32:17  quinn
  62  * Trivial
  63  *
  64  * Revision 1.7  1994/09/28  11:56:25  quinn
  65  * Added sort of input to is_merge
  66  *
  67  * Revision 1.6  1994/09/28  11:29:33  quinn
  68  * Added cmp parameter.
  69  *
  70  * Revision 1.5  1994/09/27  20:03:50  quinn
  71  * Seems relatively bug-free.
  72  *
  73  * Revision 1.4  1994/09/26  17:11:29  quinn
  74  * Trivial
  75  *
  76  * Revision 1.3  1994/09/26  17:06:35  quinn
  77  * Back again...
  78  *
  79  * Revision 1.1  1994/09/12  08:02:13  quinn
  80  * Not functional yet
  81  *
  82  */
  83
  84 #include <stdio.h>
  85 #include <stdlib.h>
  86 #include <string.h>
  87 #include <ctype.h>
  88
  89 #include <zebrautl.h>
  90 #include <bfile.h>
  91 #include <isam.h>
  92 #include "isutil.h"
  93 #include "rootblk.h"
  94 #include "keyops.h"
  95
  96 static ispt_struct *ispt_freelist = 0;
  97
  98 static struct
  99 {
 100     int total_merge_operations;
 101     int total_items;
 102     int dub_items_removed;
 103     int new_items;
 104     int failed_deletes;
 105     int skipped_inserts;
 106     int delete_insert_noop;
 107     int delete_replace;
 108     int delete;
 109     int remaps;
 110     int block_jumps;
 111     int tab_deletes;
 112     int new_tables;
 113 } statistics;
 114
 115 static ISPT ispt_alloc()
 116 {
 117     ISPT p;
 118
 119     if (ispt_freelist)
 120     {
 121         p = ispt_freelist;
 122         ispt_freelist = ispt_freelist->next;
 123     }
 124     else
 125         p = xmalloc(sizeof(ispt_struct));
 126     return p;
 127 }
 128
 129 static void ispt_free(ISPT pt)
 130 {
 131     pt->next = ispt_freelist;
 132     ispt_freelist = pt;
 133 }
 134
 135 static int splitargs(const char *s, char *bf[], int max)
 136 {
 137     int ct = 0;
 138     for (;;)
 139     {
 140         while (*s && isspace(*s))
 141             s++;
 142         bf[ct] = (char *) s;
 143         if (!*s)
 144                 return ct;
 145         ct++;
 146         if (ct > max)
 147         {
 148             logf (LOG_WARN, "Ignoring extra args to is resource");
 149             bf[ct] = '\0';
 150             return(ct - 1);
 151         }
 152         while (*s && !isspace(*s))
 153             s++;
 154     }
 155 }
 156
 157 /*
 158  * Open isam file.
 159  * Process resources.
 160  */
 161 ISAM is_open(BFiles bfs, const char *name,
 162              int (*cmp)(const void *p1, const void *p2),
 163              int writeflag, int keysize, Res res)
 164 {
 165     ISAM new;
 166     char *nm, *r, *pp[IS_MAX_BLOCKTYPES+1], m[2];
 167     int num, size, rs, tmp, i;
 168     is_type_header th;
 169
 170     logf (LOG_DEBUG, "is_open(%s, %s)", name, writeflag ? "RW" : "RDONLY");
 171     if (writeflag)
 172     {
 173         statistics.total_merge_operations = 0;
 174         statistics.total_items = 0;
 175         statistics.dub_items_removed = 0;
 176         statistics.new_items = 0;
 177         statistics.failed_deletes = 0;
 178         statistics.skipped_inserts = 0;
 179         statistics.delete_insert_noop = 0;
 180         statistics.delete_replace = 0;
 181         statistics.delete = 0;
 182         statistics.remaps = 0;
 183         statistics.new_tables = 0;
 184         statistics.block_jumps = 0;
 185         statistics.tab_deletes = 0;
 186     }
 187
 188     new = xmalloc(sizeof(*new));
 189     new->writeflag = writeflag;
 190     for (i = 0; i < IS_MAX_BLOCKTYPES; i++)
 191         new->types[i].index = 0;                        /* dummy */
 192
 193     /* determine number and size of blocktypes */
 194     if (!(r = res_get_def(res,
 195                           nm = strconcat(name, ".",
 196                                          "blocktypes", 0), "64 512 4K 32K")) ||
 197         !(num = splitargs(r, pp, IS_MAX_BLOCKTYPES)))
 198     {
 199         logf (LOG_FATAL, "Failed to locate resource %s", nm);
 200         return 0;
 201     }
 202     new->num_types = num;
 203     for (i = 0; i < num; i++)
 204     {
 205         if ((rs = sscanf(pp[i], "%d%1[bBkKmM]", &size, m)) < 1)
 206         {
 207             logf (LOG_FATAL, "Error in resource %s: %s", r, pp[i]);
 208             return 0;
 209         }
 210         if (rs == 1)
 211                 *m = 'b';
 212         switch (*m)
 213         {
 214                 case 'b': case 'B':
 215                     new->types[i].blocksize = size; break;
 216                 case 'k': case 'K':
 217                     new->types[i].blocksize = size * 1024; break;
 218                 case 'm': case 'M':
 219                     new->types[i].blocksize = size * 1048576; break;
 220                 default:
 221                     logf (LOG_FATAL, "Illegal size suffix: %c", *m);
 222                     return 0;
 223         }
 224         new->types[i].dbuf = xmalloc(new->types[i].blocksize);
 225         m[0] = 'A' + i;
 226         m[1] = '\0';
 227         if (!(new->types[i].bf = bf_open(bfs, strconcat(name, m, 0),
 228             new->types[i].blocksize, writeflag)))
 229         {
 230             logf (LOG_FATAL, "bf_open failed");
 231             return 0;
 232         }
 233         if ((rs = is_rb_read(&new->types[i], &th)) > 0)
 234         {
 235             if (th.blocksize != new->types[i].blocksize)
 236             {
 237                 logf (LOG_FATAL, "File blocksize mismatch in %s", name);
 238                 exit(1);
 239             }
 240             new->types[i].freelist = th.freelist;
 241             new->types[i].top = th.top;
 242         }
 243         else if (writeflag) /* write dummy superblock to determine top */
 244         {
 245             if ((rs = is_rb_write(&new->types[i], &th)) <=0)  /* dummy */
 246             {
 247                 logf (LOG_FATAL, "Failed to write initial superblock.");
 248                 exit(1);
 249             }
 250             new->types[i].freelist = -1;
 251             new->types[i].top = rs;
 252         }
 253         /* ELSE: this is an empty file opened in read-only mode. */
 254     }
 255     if (keysize > 0)
 256         new->keysize = keysize;
 257     else
 258     {
 259         if (!(r = res_get_def(res, nm = strconcat(name, ".",
 260                                                   "keysize", 0), "4")))
 261         {
 262             logf (LOG_FATAL, "Failed to locate resource %s", nm);
 263             return 0;
 264         }
 265         if ((new->keysize = atoi(r)) <= 0)
 266         {
 267             logf (LOG_FATAL, "Must specify positive keysize.");
 268             return 0;
 269         }
 270     }
 271
 272     /* determine repack percent */
 273     if (!(r = res_get_def(res, nm = strconcat(name, ".", "repack",
 274                                               0), IS_DEF_REPACK_PERCENT)))
 275     {
 276         logf (LOG_FATAL, "Failed to locate resource %s", nm);
 277         return 0;
 278     }
 279     new->repack = atoi(r);
 280
 281     /* determine max keys/blocksize */
 282     if (!(r = res_get_def(res,
 283                           nm = strconcat(name, ".",
 284                                          "maxkeys", 0), "50 640 10000")) ||
 285         !(num = splitargs(r, pp, IS_MAX_BLOCKTYPES)))
 286     {
 287         logf (LOG_FATAL, "Failed to locate resource %s", nm);
 288         return 0;
 289     }
 290     if (num < new->num_types -1)
 291     {
 292         logf (LOG_FATAL, "Not enough elements in %s", nm);
 293         return 0;
 294     }
 295     for (i = 0; i < num; i++)
 296     {
 297         if ((rs = sscanf(pp[i], "%d", &tmp)) < 1)
 298         {
 299             logf (LOG_FATAL, "Error in resource %s: %s", r, pp[i]);
 300             return 0;
 301         }
 302         new->types[i].max_keys = tmp;
 303     }
 304
 305     /* determine max keys/block */
 306     for (i = 0; i < new->num_types; i++)
 307     {
 308         if (!new->types[i].index)
 309         {
 310             new->types[i].max_keys_block = (new->types[i].blocksize - 2 *
 311                 sizeof(int)) / new->keysize;
 312             new->types[i].max_keys_block0 = (new->types[i].blocksize - 3 *
 313                 sizeof(int)) / new->keysize;
 314         }
 315         else
 316             new->types[i].max_keys_block = new->types[i].max_keys_block0 /
 317                 new->keysize;
 318         if (new->types[i].max_keys_block0 < 1)
 319         {
 320             logf (LOG_FATAL, "Blocksize too small in %s", name);
 321             exit(1);
 322         }
 323     }
 324
 325     /* determine nice fill rates */
 326     if (!(r = res_get_def(res,
 327                           nm = strconcat(name, ".",
 328                                          "nicefill", 0), "90 90 90 95")) ||
 329         !(num = splitargs(r, pp, IS_MAX_BLOCKTYPES)))
 330     {
 331         logf (LOG_FATAL, "Failed to locate resource %s", nm);
 332         return 0;
 333     }
 334     if (num < new->num_types)
 335     {
 336         logf (LOG_FATAL, "Not enough elements in %s", nm);
 337         return 0;
 338     }
 339     for (i = 0; i < num; i++)
 340     {
 341         if ((rs = sscanf(pp[i], "%d", &tmp)) < 1)
 342         {
 343             logf (LOG_FATAL, "Error in resource %s: %s", r, pp[i]);
 344             return 0;
 345         }
 346         new->types[i].nice_keys_block = (new->types[i].max_keys_block0 * tmp) /
 347             100;
 348         if (new->types[i].nice_keys_block < 1)
 349                 new->types[i].nice_keys_block = 1;
 350     }
 351
 352     new->cmp = cmp ? cmp : is_default_cmp;
 353     return new;
 354 }
 355
 356 /*
 357  * Close isam file.
 358  */
 359 int is_close(ISAM is)
 360 {
 361     int i;
 362     is_type_header th;
 363
 364     logf (LOG_DEBUG, "is_close()");
 365     for (i = 0; i < is->num_types; i++)
 366     {
 367         if (is->types[i].bf)
 368         {
 369             if (is->writeflag)
 370             {
 371                 th.blocksize = is->types[i].blocksize;
 372                 th.keysize = is->keysize;
 373                 th.freelist = is->types[i].freelist;
 374                 th.top = is->types[i].top;
 375                 if (is_rb_write(&is->types[i], &th) < 0)
 376                 {
 377                     logf (LOG_FATAL, "Failed to write headerblock");
 378                     exit(1);
 379                 }
 380             }
 381             bf_close(is->types[i].bf);
 382         }
 383     }
 384     for (i = 0; i < is->num_types; i++)
 385         xfree (is->types[i].dbuf);
 386
 387     if (is->writeflag)
 388     {
 389         logf(LOG_LOG, "ISAM statistics:");
 390         logf(LOG_LOG, "total_merge_operations      %d",
 391             statistics.total_merge_operations);
 392         logf(LOG_LOG, "total_items                 %d", statistics.total_items);
 393         logf(LOG_LOG, "dub_items_removed           %d",
 394             statistics.dub_items_removed);
 395         logf(LOG_LOG, "new_items                   %d", statistics.new_items);
 396         logf(LOG_LOG, "failed_deletes              %d",
 397             statistics.failed_deletes);
 398         logf(LOG_LOG, "skipped_inserts             %d",
 399             statistics.skipped_inserts);
 400         logf(LOG_LOG, "delete_insert_noop          %d",
 401             statistics.delete_insert_noop);
 402         logf(LOG_LOG, "delete_replace              %d",
 403             statistics.delete_replace);
 404         logf(LOG_LOG, "delete                      %d", statistics.delete);
 405         logf(LOG_LOG, "remaps                      %d", statistics.remaps);
 406         logf(LOG_LOG, "block_jumps                 %d", statistics.block_jumps);
 407         logf(LOG_LOG, "tab_deletes                 %d", statistics.tab_deletes);
 408     }
 409     xfree(is);
 410     return 0;
 411 }
 412
 413 static ISAM_P is_address(int type, int pos)
 414 {
 415     ISAM_P r;
 416
 417     r = pos << 2;
 418     r |= type;
 419     return r;
 420 }
 421
 422 ISAM_P is_merge(ISAM is, ISAM_P pos, int num, char *data)
 423 {
 424     is_mtable tab;
 425     int res;
 426     char keybuf[IS_MAX_RECORD];
 427     int oldnum, oldtype, i;
 428     char operation, *record;
 429
 430     statistics.total_merge_operations++;
 431     statistics.total_items += num;
 432     if (!pos)
 433         statistics.new_tables++;
 434
 435     is_m_establish_tab(is, &tab, pos);
 436     if (pos)
 437         if (is_m_read_full(&tab, tab.data) < 0)
 438         {
 439             logf (LOG_FATAL, "read_full failed");
 440             exit(1);
 441         }
 442     oldnum = tab.num_records;
 443     oldtype = tab.pos_type;
 444     while (num)
 445     {
 446         operation = *(data)++;
 447         record = (char*) data;
 448         data += is_keysize(is);
 449         num--;
 450         while (num && !memcmp(record - 1, data, is_keysize(tab.is) + 1))
 451         {
 452             data += 1 + is_keysize(is);
 453             num--;
 454             statistics.dub_items_removed++;
 455         }
 456         if ((res = is_m_seek_record(&tab, record)) > 0)  /* no match */
 457         {
 458             if (operation == KEYOP_INSERT)
 459             {
 460                 logf (LOG_DEBUG, "XXInserting new record.");
 461                 is_m_write_record(&tab, record);
 462                 statistics.new_items++;
 463             }
 464             else
 465             {
 466                 logf (LOG_DEBUG, "XXDeletion failed to find match.");
 467                 statistics.failed_deletes++;
 468             }
 469         }
 470         else /* match found */
 471         {
 472             if (operation == KEYOP_INSERT)
 473             {
 474                 logf (LOG_DEBUG, "XXSkipping insertion - match found.");
 475                 statistics.skipped_inserts++;
 476                 continue;
 477             }
 478             else if (operation == KEYOP_DELETE)
 479             {
 480                 /* try to avoid needlessly moving data */
 481                 if (num && *(data) == KEYOP_INSERT)
 482                 {
 483                     /* next key is identical insert? - NOOP - skip it */
 484                     if (!memcmp(record, data + 1, is_keysize(is)))
 485                     {
 486                         logf (LOG_DEBUG, "XXNoop delete. skipping.");
 487                         data += 1 + is_keysize(is);
 488                         num--;
 489                         while (num && !memcmp(data, data + is_keysize(tab.is) +
 490                             1, is_keysize(tab.is) + 1))
 491                         {
 492                             data += 1 + is_keysize(is);
 493                             num--;
 494                             statistics.dub_items_removed++;
 495                         }
 496                         statistics.delete_insert_noop++;
 497                         continue;
 498                     }
 499                     /* else check if next key can fit in this position */
 500                     if (is_m_peek_record(&tab, keybuf) &&
 501                         (*is->cmp)(data + 1, keybuf) < 0)
 502                     {
 503                         logf (LOG_DEBUG, "XXReplacing record.");
 504                         is_m_replace_record(&tab, data + 1);
 505                         data += 1 + is_keysize(is);
 506                         num--;
 507                         while (num && !memcmp(data, data + is_keysize(tab.is) +
 508                             1, is_keysize(tab.is) + 1))
 509                         {
 510                             data += 1 + is_keysize(is);
 511                             num--;
 512                             statistics.dub_items_removed++;
 513                         }
 514                         statistics.delete_replace++;
 515                         continue;
 516                     }
 517                 }
 518                 logf (LOG_DEBUG, "Deleting record.");
 519                 is_m_delete_record(&tab);
 520                 statistics.delete++;
 521             }
 522         }
 523     }
 524     i = tab.pos_type;
 525     while (i < tab.is->num_types - 1 && tab.num_records >
 526         tab.is->types[i].max_keys)
 527         i++;
 528     if (i != tab.pos_type)
 529     {
 530         /* read remaining blocks */
 531         for (; tab.cur_mblock; tab.cur_mblock = tab.cur_mblock->next)
 532             if (tab.cur_mblock->state < IS_MBSTATE_CLEAN)
 533                 is_m_read_full(&tab, tab.cur_mblock);
 534         is_p_unmap(&tab);
 535         tab.pos_type = i;
 536         if (pos)
 537             statistics.block_jumps++;
 538     }
 539     if (!oldnum || tab.pos_type != oldtype || (abs(oldnum - tab.num_records) *
 540         100) / oldnum > tab.is->repack)
 541     {
 542         is_p_remap(&tab);
 543         statistics.remaps++;
 544     }
 545     else
 546         is_p_align(&tab);
 547     if (tab.data)
 548     {
 549         is_p_sync(&tab);
 550         pos = is_address(tab.pos_type, tab.data->diskpos);
 551     }
 552     else
 553     {
 554         pos = 0;
 555         statistics.tab_deletes++;
 556     }
 557     is_m_release_tab(&tab);
 558     return pos;
 559 }
 560
 561 /*
 562  * Locate a table of keys in an isam file. The ISPT is an individual
 563  * position marker for that table.
 564  */
 565 ISPT is_position(ISAM is, ISAM_P pos)
 566 {
 567     ispt_struct *p;
 568
 569     p = ispt_alloc();
 570     is_m_establish_tab(is, &p->tab, pos);
 571     return p;
 572 }
 573
 574 /*
 575  * Release ISPT.
 576  */
 577 void is_pt_free(ISPT ip)
 578 {
 579     is_m_release_tab(&ip->tab);
 580     ispt_free(ip);
 581 }
 582
 583 /*
 584  * Read a key from a table.
 585  */
 586 int is_readkey(ISPT ip, void *buf)
 587 {
 588     return is_m_read_record(&ip->tab, buf, 0);
 589 }
 590
 591 int is_numkeys(ISPT ip)
 592 {
 593     return is_m_num_records(&ip->tab);
 594 }
 595
 596 void is_rewind(ISPT ip)
 597 {
 598     is_m_rewind(&ip->tab);
 599 }