index/trunc.c

   1 /*
   2  * Copyright (C) 1994-1999, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: trunc.c,v $
   7  * Revision 1.19  2001-01-16 16:56:15  heikki
   8  * Searching in my isam-d
   9  *
  10  * Revision 1.18  2000/05/18 12:01:36  adam
  11  * System call times(2) used again. More 64-bit fixes.
  12  *
  13  * Revision 1.17  2000/03/15 15:00:30  adam
  14  * First work on threaded version.
  15  *
  16  * Revision 1.16  1999/11/30 13:48:03  adam
  17  * Improved installation. Updated for inclusion of YAZ header files.
  18  *
  19  * Revision 1.15  1999/07/20 13:59:18  adam
  20  * Fixed bug that occurred when phrases had 0 hits.
  21  *
  22  * Revision 1.14  1999/05/26 07:49:13  adam
  23  * C++ compilation.
  24  *
  25  * Revision 1.13  1999/05/12 13:08:06  adam
  26  * First version of ISAMS.
  27  *
  28  * Revision 1.12  1999/02/02 14:51:10  adam
  29  * Updated WIN32 code specific sections. Changed header.
  30  *
  31  * Revision 1.11  1998/03/25 13:48:02  adam
  32  * Fixed bug in rset_trunc_r.
  33  *
  34  * Revision 1.10  1998/03/05 08:45:13  adam
  35  * New result set model and modular ranking system. Moved towards
  36  * descent server API. System information stored as "SGML" records.
  37  *
  38  * Revision 1.9  1998/01/12 15:04:09  adam
  39  * The test option (-s) only uses read-lock (and not write lock).
  40  *
  41  * Revision 1.8  1997/10/31 12:34:27  adam
  42  * Bug fix: memory leak.
  43  *
  44  * Revision 1.7  1997/09/29 09:07:29  adam
  45  * Minor change.
  46  *
  47  * Revision 1.6  1997/09/22 12:39:06  adam
  48  * Added get_pos method for the ranked result sets.
  49  *
  50  * Revision 1.5  1997/09/17 12:19:17  adam
  51  * Zebra version corresponds to YAZ version 1.4.
  52  * Changed Zebra server so that it doesn't depend on global common_resource.
  53  *
  54  * Revision 1.4  1996/12/23 15:30:44  adam
  55  * Work on truncation.
  56  * Bug fix: result sets weren't deleted after server shut down.
  57  *
  58  * Revision 1.3  1996/12/20 11:07:14  adam
  59  * Multi-or result set.
  60  *
  61  * Revision 1.2  1996/11/08 11:10:28  adam
  62  * Buffers used during file match got bigger.
  63  * Compressed ISAM support everywhere.
  64  * Bug fixes regarding masking characters in queries.
  65  * Redesigned Regexp-2 queries.
  66  *
  67  * Revision 1.1  1996/11/04 14:07:40  adam
  68  * Moved truncation code to trunc.c.
  69  *
  70  */
  71 #include <stdio.h>
  72 #include <assert.h>
  73
  74 #define NEW_TRUNC 1
  75
  76 #include "zserver.h"
  77 #include <rstemp.h>
  78 #include <rsnull.h>
  79 #include <rsisams.h>
  80 #if ZMBOL
  81 #include <rsisam.h>
  82 #include <rsisamc.h>
  83 #include <rsisamd.h>
  84 #if NEW_TRUNC
  85 #include <rsm_or.h>
  86 #endif
  87 #endif
  88
  89 struct trunc_info {
  90     int  *ptr;
  91     int  *indx;
  92     char **heap;
  93     int  heapnum;
  94     int  (*cmp)(const void *p1, const void *p2);
  95     int  keysize;
  96     char *swapbuf;
  97     char *tmpbuf;
  98     char *buf;
  99 };
 100
 101 static void heap_swap (struct trunc_info *ti, int i1, int i2)
 102 {
 103     int swap;
 104
 105     swap = ti->ptr[i1];
 106     ti->ptr[i1] = ti->ptr[i2];
 107     ti->ptr[i2] = swap;
 108 }
 109
 110 static void heap_delete (struct trunc_info *ti)
 111 {
 112     int cur = 1, child = 2;
 113
 114     heap_swap (ti, 1, ti->heapnum--);
 115     while (child <= ti->heapnum) {
 116         if (child < ti->heapnum &&
 117             (*ti->cmp)(ti->heap[ti->ptr[child]],
 118                        ti->heap[ti->ptr[1+child]]) > 0)
 119             child++;
 120         if ((*ti->cmp)(ti->heap[ti->ptr[cur]],
 121                        ti->heap[ti->ptr[child]]) > 0)
 122         {
 123             heap_swap (ti, cur, child);
 124             cur = child;
 125             child = 2*cur;
 126         }
 127         else
 128             break;
 129     }
 130 }
 131
 132 static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
 133 {
 134     int cur, parent;
 135
 136     cur = ++(ti->heapnum);
 137     memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize);
 138     ti->indx[ti->ptr[cur]] = indx;
 139     parent = cur/2;
 140     while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]],
 141                                 ti->heap[ti->ptr[cur]]) > 0)
 142     {
 143         heap_swap (ti, cur, parent);
 144         cur = parent;
 145         parent = cur/2;
 146     }
 147 }
 148
 149 static struct trunc_info *heap_init (int size, int key_size,
 150                                      int (*cmp)(const void *p1,
 151                                                 const void *p2))
 152 {
 153     struct trunc_info *ti = (struct trunc_info *) xmalloc (sizeof(*ti));
 154     int i;
 155
 156     ++size;
 157     ti->heapnum = 0;
 158     ti->keysize = key_size;
 159     ti->cmp = cmp;
 160     ti->indx = (int *) xmalloc (size * sizeof(*ti->indx));
 161     ti->heap = (char **) xmalloc (size * sizeof(*ti->heap));
 162     ti->ptr = (int *) xmalloc (size * sizeof(*ti->ptr));
 163     ti->swapbuf = (char *) xmalloc (ti->keysize);
 164     ti->tmpbuf = (char *) xmalloc (ti->keysize);
 165     ti->buf = (char *) xmalloc (size * ti->keysize);
 166     for (i = size; --i >= 0; )
 167     {
 168         ti->ptr[i] = i;
 169         ti->heap[i] = ti->buf + ti->keysize * i;
 170     }
 171     return ti;
 172 }
 173
 174 static void heap_close (struct trunc_info *ti)
 175 {
 176     xfree (ti->ptr);
 177     xfree (ti->indx);
 178     xfree (ti->heap);
 179     xfree (ti->swapbuf);
 180     xfree (ti->tmpbuf);
 181     xfree (ti->buf);
 182     xfree (ti);
 183 }
 184
 185 static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
 186                          const char *flags, ISAMS_P *isam_p, int from, int to,
 187                          int merge_chunk)
 188 {
 189     RSET result;
 190     RSFD result_rsfd;
 191     rset_temp_parms parms;
 192
 193     parms.key_size = sizeof(struct it_key);
 194     parms.temp_path = res_get (zi->service->res, "setTmpDir");
 195     parms.rset_term = rset_term_create (term, length, flags);
 196     result = rset_create (rset_kind_temp, &parms);
 197     result_rsfd = rset_open (result, RSETF_WRITE);
 198
 199     if (to - from > merge_chunk)
 200     {
 201         RSFD *rsfd;
 202         RSET *rset;
 203         int term_index;
 204         int i, i_add = (to-from)/merge_chunk + 1;
 205         struct trunc_info *ti;
 206         int rscur = 0;
 207         int rsmax = (to-from)/i_add + 1;
 208
 209         rset = (RSET *) xmalloc (sizeof(*rset) * rsmax);
 210         rsfd = (RSFD *) xmalloc (sizeof(*rsfd) * rsmax);
 211
 212         for (i = from; i < to; i += i_add)
 213         {
 214             if (i_add <= to - i)
 215                 rset[rscur] = rset_trunc_r (zi, term, length, flags,
 216                                             isam_p, i, i+i_add, merge_chunk);
 217             else
 218                 rset[rscur] = rset_trunc_r (zi, term, length, flags,
 219                                             isam_p, i, to, merge_chunk);
 220             rscur++;
 221         }
 222         ti = heap_init (rscur, sizeof(struct it_key), key_compare_it);
 223         for (i = rscur; --i >= 0; )
 224         {
 225             rsfd[i] = rset_open (rset[i], RSETF_READ);
 226             if (rset_read (rset[i], rsfd[i], ti->tmpbuf, &term_index))
 227                 heap_insert (ti, ti->tmpbuf, i);
 228             else
 229             {
 230                 rset_close (rset[i], rsfd[i]);
 231                 rset_delete (rset[i]);
 232             }
 233         }
 234         while (ti->heapnum)
 235         {
 236             int n = ti->indx[ti->ptr[1]];
 237
 238             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 239
 240             while (1)
 241             {
 242                 if (!rset_read (rset[n], rsfd[n], ti->tmpbuf, &term_index))
 243                 {
 244                     heap_delete (ti);
 245                     rset_close (rset[n], rsfd[n]);
 246                     rset_delete (rset[n]);
 247                     break;
 248                 }
 249                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 250                 {
 251                     heap_delete (ti);
 252                     heap_insert (ti, ti->tmpbuf, n);
 253                     break;
 254                 }
 255             }
 256         }
 257         xfree (rset);
 258         xfree (rsfd);
 259         heap_close (ti);
 260     }
 261 #if ZMBOL
 262     else if (zi->service->isam)
 263     {
 264         ISPT *ispt;
 265         int i;
 266         struct trunc_info *ti;
 267
 268         ispt = (ISPT *) xmalloc (sizeof(*ispt) * (to-from));
 269
 270         ti = heap_init (to-from, sizeof(struct it_key),
 271                         key_compare_it);
 272         for (i = to-from; --i >= 0; )
 273         {
 274             ispt[i] = is_position (zi->service->isam, isam_p[from+i]);
 275             if (is_readkey (ispt[i], ti->tmpbuf))
 276                 heap_insert (ti, ti->tmpbuf, i);
 277             else
 278                 is_pt_free (ispt[i]);
 279         }
 280         while (ti->heapnum)
 281         {
 282             int n = ti->indx[ti->ptr[1]];
 283
 284             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 285 #if 1
 286 /* section that preserve all keys */
 287             heap_delete (ti);
 288             if (is_readkey (ispt[n], ti->tmpbuf))
 289                 heap_insert (ti, ti->tmpbuf, n);
 290             else
 291                 is_pt_free (ispt[n]);
 292 #else
 293 /* section that preserve all keys with unique sysnos */
 294             while (1)
 295             {
 296                 if (!is_readkey (ispt[n], ti->tmpbuf))
 297                 {
 298                     heap_delete (ti);
 299                     is_pt_free (ispt[n]);
 300                     break;
 301                 }
 302                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 303                 {
 304                     heap_delete (ti);
 305                     heap_insert (ti, ti->tmpbuf, n);
 306                     break;
 307                 }
 308             }
 309 #endif
 310         }
 311         heap_close (ti);
 312         xfree (ispt);
 313     }
 314     else if (zi->service->isamc)
 315     {
 316         ISAMC_PP *ispt;
 317         int i;
 318         struct trunc_info *ti;
 319
 320         ispt = (ISAMC_PP *) xmalloc (sizeof(*ispt) * (to-from));
 321
 322         ti = heap_init (to-from, sizeof(struct it_key),
 323                         key_compare_it);
 324         for (i = to-from; --i >= 0; )
 325         {
 326             ispt[i] = isc_pp_open (zi->service->isamc, isam_p[from+i]);
 327             if (isc_pp_read (ispt[i], ti->tmpbuf))
 328                 heap_insert (ti, ti->tmpbuf, i);
 329             else
 330                 isc_pp_close (ispt[i]);
 331         }
 332         while (ti->heapnum)
 333         {
 334             int n = ti->indx[ti->ptr[1]];
 335
 336             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 337 #if 0
 338 /* section that preserve all keys */
 339             heap_delete (ti);
 340             if (isc_pp_read (ispt[n], ti->tmpbuf))
 341                 heap_insert (ti, ti->tmpbuf, n);
 342             else
 343                 isc_pp_close (ispt[n]);
 344 #else
 345 /* section that preserve all keys with unique sysnos */
 346             while (1)
 347             {
 348                 if (!isc_pp_read (ispt[n], ti->tmpbuf))
 349                 {
 350                     heap_delete (ti);
 351                     isc_pp_close (ispt[n]);
 352                     break;
 353                 }
 354                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 355                 {
 356                     heap_delete (ti);
 357                     heap_insert (ti, ti->tmpbuf, n);
 358                     break;
 359                 }
 360             }
 361 #endif
 362         }
 363         heap_close (ti);
 364         xfree (ispt);
 365     }
 366
 367     else if (zi->service->isamd)
 368     {
 369         ISAMD_PP *ispt;
 370         int i;
 371         struct trunc_info *ti;
 372
 373         ispt = (ISAMD_PP *) xmalloc (sizeof(*ispt) * (to-from));
 374
 375         ti = heap_init (to-from, sizeof(struct it_key),
 376                         key_compare_it);
 377         for (i = to-from; --i >= 0; )
 378         {
 379             ispt[i] = isamd_pp_open (zi->service->isamd, isam_p[from+i]);
 380             if (isamd_pp_read (ispt[i], ti->tmpbuf))
 381                 heap_insert (ti, ti->tmpbuf, i);
 382             else
 383                 isamd_pp_close (ispt[i]);
 384         }
 385         while (ti->heapnum)
 386         {
 387             int n = ti->indx[ti->ptr[1]];
 388
 389             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 390 #if 0
 391 /* section that preserve all keys */
 392             heap_delete (ti);
 393             if (isamd_pp_read (ispt[n], ti->tmpbuf))
 394                 heap_insert (ti, ti->tmpbuf, n);
 395             else
 396                 isamd_pp_close (ispt[n]);
 397 #else
 398 /* section that preserve all keys with unique sysnos */
 399             while (1)
 400             {
 401                 if (!isamd_pp_read (ispt[n], ti->tmpbuf))
 402                 {
 403                     heap_delete (ti);
 404                     isamd_pp_close (ispt[n]);
 405                     break;
 406                 }
 407                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 408                 {
 409                     heap_delete (ti);
 410                     heap_insert (ti, ti->tmpbuf, n);
 411                     break;
 412                 }
 413             }
 414 #endif
 415         }
 416         heap_close (ti);
 417         xfree (ispt);
 418     }
 419
 420 #endif
 421     else if (zi->service->isams)
 422     {
 423         ISAMS_PP *ispt;
 424         int i;
 425         struct trunc_info *ti;
 426
 427         ispt = (ISAMS_PP *) xmalloc (sizeof(*ispt) * (to-from));
 428
 429         ti = heap_init (to-from, sizeof(struct it_key),
 430                         key_compare_it);
 431         for (i = to-from; --i >= 0; )
 432         {
 433             ispt[i] = isams_pp_open (zi->service->isams, isam_p[from+i]);
 434             if (isams_pp_read (ispt[i], ti->tmpbuf))
 435                 heap_insert (ti, ti->tmpbuf, i);
 436             else
 437                 isams_pp_close (ispt[i]);
 438         }
 439         while (ti->heapnum)
 440         {
 441             int n = ti->indx[ti->ptr[1]];
 442
 443             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 444             while (1)
 445             {
 446                 if (!isams_pp_read (ispt[n], ti->tmpbuf))
 447                 {
 448                     heap_delete (ti);
 449                     isams_pp_close (ispt[n]);
 450                     break;
 451                 }
 452                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 453                 {
 454                     heap_delete (ti);
 455                     heap_insert (ti, ti->tmpbuf, n);
 456                     break;
 457                 }
 458             }
 459         }
 460         heap_close (ti);
 461         xfree (ispt);
 462     }
 463     else
 464         logf (LOG_WARN, "Unknown isam set in rset_trunc_r");
 465
 466     rset_close (result, result_rsfd);
 467     return result;
 468 }
 469
 470 static int isams_trunc_cmp (const void *p1, const void *p2)
 471 {
 472     ISAMS_P i1 = *(ISAMS_P*) p1;
 473     ISAMS_P i2 = *(ISAMS_P*) p2;
 474
 475     return i1 - i2;
 476 }
 477
 478 #if ZMBOL
 479 static int isam_trunc_cmp (const void *p1, const void *p2)
 480 {
 481     ISAM_P i1 = *(ISAM_P*) p1;
 482     ISAM_P i2 = *(ISAM_P*) p2;
 483     int d;
 484
 485     d = is_type (i1) - is_type (i2);
 486     if (d)
 487         return d;
 488     return is_block (i1) - is_block (i2);
 489 }
 490
 491 static int isamc_trunc_cmp (const void *p1, const void *p2)
 492 {
 493     ISAMC_P i1 = *(ISAMC_P*) p1;
 494     ISAMC_P i2 = *(ISAMC_P*) p2;
 495     int d;
 496
 497     d = isc_type (i1) - isc_type (i2);
 498     if (d)
 499         return d;
 500     return isc_block (i1) - isc_block (i2);
 501 }
 502 static int isamd_trunc_cmp (const void *p1, const void *p2)
 503 {
 504     ISAMD_P i1 = *(ISAMD_P*) p1;
 505     ISAMD_P i2 = *(ISAMD_P*) p2;
 506     int d;
 507
 508     d = isamd_type (i1) - isamd_type (i2);
 509     if (d)
 510         return d;
 511     return isamd_block (i1) - isamd_block (i2);
 512 }
 513 #endif
 514
 515 RSET rset_trunc (ZebraHandle zi, ISAMS_P *isam_p, int no,
 516                  const char *term, int length, const char *flags)
 517 {
 518     logf (LOG_DEBUG, "rset_trunc no=%d", no);
 519     if (no < 1)
 520     {
 521         rset_null_parms parms;
 522         parms.rset_term = rset_term_create (term, length, flags);
 523         return rset_create (rset_kind_null, &parms);
 524     }
 525     if (zi->service->isams)
 526     {
 527         if (no == 1)
 528         {
 529             rset_isams_parms parms;
 530
 531             parms.pos = *isam_p;
 532             parms.is = zi->service->isams;
 533             parms.rset_term = rset_term_create (term, length, flags);
 534             return rset_create (rset_kind_isams, &parms);
 535         }
 536         qsort (isam_p, no, sizeof(*isam_p), isams_trunc_cmp);
 537     }
 538 #if ZMBOL
 539     else if (zi->service->isam)
 540     {
 541         if (no == 1)
 542         {
 543             rset_isam_parms parms;
 544
 545             parms.pos = *isam_p;
 546             parms.is = zi->service->isam;
 547             parms.rset_term = rset_term_create (term, length, flags);
 548             return rset_create (rset_kind_isam, &parms);
 549         }
 550         qsort (isam_p, no, sizeof(*isam_p), isam_trunc_cmp);
 551     }
 552     else if (zi->service->isamc)
 553     {
 554         if (no == 1)
 555         {
 556             rset_isamc_parms parms;
 557
 558             parms.pos = *isam_p;
 559             parms.is = zi->service->isamc;
 560             parms.rset_term = rset_term_create (term, length, flags);
 561             return rset_create (rset_kind_isamc, &parms);
 562         }
 563 #if NEW_TRUNC
 564         else if (no < 10000)
 565         {
 566             rset_m_or_parms parms;
 567
 568             parms.key_size = sizeof(struct it_key);
 569             parms.cmp = key_compare_it;
 570             parms.isc = zi->service->isamc;
 571             parms.isam_positions = isam_p;
 572             parms.no_isam_positions = no;
 573             parms.no_save_positions = 100000;
 574             parms.rset_term = rset_term_create (term, length, flags);
 575             return rset_create (rset_kind_m_or, &parms);
 576         }
 577 #endif
 578         qsort (isam_p, no, sizeof(*isam_p), isamc_trunc_cmp);
 579     }
 580     else if (zi->service->isamd)
 581     {
 582         if (no == 1)
 583         {
 584             rset_isamd_parms parms;
 585
 586             parms.pos = *isam_p;
 587             parms.is = zi->service->isamd;
 588             parms.rset_term = rset_term_create (term, length, flags);
 589             return rset_create (rset_kind_isamd, &parms);
 590         }
 591 #if NEW_TRUNC_NOT_DONE_FOR_ISAM_D
 592         else if (no < 10000)
 593         {
 594             rset_m_or_parms parms;
 595
 596             parms.key_size = sizeof(struct it_key);
 597             parms.cmp = key_compare_it;
 598             parms.isc = 0;
 599             parms.isamd=zi->service->isamd;
 600             parms.isam_positions = isam_p;
 601             parms.no_isam_positions = no;
 602             parms.no_save_positions = 100000;
 603             parms.rset_term = rset_term_create (term, length, flags);
 604             return rset_create (rset_kind_m_or, &parms);
 605         }
 606 #endif
 607         qsort (isam_p, no, sizeof(*isam_p), isamd_trunc_cmp);
 608     }
 609 #endif
 610     else
 611     {
 612         logf (LOG_WARN, "Unknown isam set in rset_trunc");
 613         return rset_create (rset_kind_null, NULL);
 614     }
 615     return rset_trunc_r (zi, term, length, flags, isam_p, 0, no, 100);
 616 }
 617