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.12  1999-02-02 14:51:10  adam
   8  * Updated WIN32 code specific sections. Changed header.
   9  *
  10  * Revision 1.11  1998/03/25 13:48:02  adam
  11  * Fixed bug in rset_trunc_r.
  12  *
  13  * Revision 1.10  1998/03/05 08:45:13  adam
  14  * New result set model and modular ranking system. Moved towards
  15  * descent server API. System information stored as "SGML" records.
  16  *
  17  * Revision 1.9  1998/01/12 15:04:09  adam
  18  * The test option (-s) only uses read-lock (and not write lock).
  19  *
  20  * Revision 1.8  1997/10/31 12:34:27  adam
  21  * Bug fix: memory leak.
  22  *
  23  * Revision 1.7  1997/09/29 09:07:29  adam
  24  * Minor change.
  25  *
  26  * Revision 1.6  1997/09/22 12:39:06  adam
  27  * Added get_pos method for the ranked result sets.
  28  *
  29  * Revision 1.5  1997/09/17 12:19:17  adam
  30  * Zebra version corresponds to YAZ version 1.4.
  31  * Changed Zebra server so that it doesn't depend on global common_resource.
  32  *
  33  * Revision 1.4  1996/12/23 15:30:44  adam
  34  * Work on truncation.
  35  * Bug fix: result sets weren't deleted after server shut down.
  36  *
  37  * Revision 1.3  1996/12/20 11:07:14  adam
  38  * Multi-or result set.
  39  *
  40  * Revision 1.2  1996/11/08 11:10:28  adam
  41  * Buffers used during file match got bigger.
  42  * Compressed ISAM support everywhere.
  43  * Bug fixes regarding masking characters in queries.
  44  * Redesigned Regexp-2 queries.
  45  *
  46  * Revision 1.1  1996/11/04 14:07:40  adam
  47  * Moved truncation code to trunc.c.
  48  *
  49  */
  50 #include <stdio.h>
  51 #include <assert.h>
  52
  53 #include "zserver.h"
  54 #include <rstemp.h>
  55 #include <rsisam.h>
  56 #include <rsisamc.h>
  57 #include <rsnull.h>
  58
  59 #define NEW_TRUNC 1
  60
  61 #if NEW_TRUNC
  62 #include <rsm_or.h>
  63 #endif
  64
  65 struct trunc_info {
  66     int  *ptr;
  67     int  *indx;
  68     char **heap;
  69     int  heapnum;
  70     int  (*cmp)(const void *p1, const void *p2);
  71     int  keysize;
  72     char *swapbuf;
  73     char *tmpbuf;
  74     char *buf;
  75 };
  76
  77 static void heap_swap (struct trunc_info *ti, int i1, int i2)
  78 {
  79     int swap;
  80
  81     swap = ti->ptr[i1];
  82     ti->ptr[i1] = ti->ptr[i2];
  83     ti->ptr[i2] = swap;
  84 }
  85
  86 static void heap_delete (struct trunc_info *ti)
  87 {
  88     int cur = 1, child = 2;
  89
  90     heap_swap (ti, 1, ti->heapnum--);
  91     while (child <= ti->heapnum) {
  92         if (child < ti->heapnum &&
  93             (*ti->cmp)(ti->heap[ti->ptr[child]],
  94                        ti->heap[ti->ptr[1+child]]) > 0)
  95             child++;
  96         if ((*ti->cmp)(ti->heap[ti->ptr[cur]],
  97                        ti->heap[ti->ptr[child]]) > 0)
  98         {
  99             heap_swap (ti, cur, child);
 100             cur = child;
 101             child = 2*cur;
 102         }
 103         else
 104             break;
 105     }
 106 }
 107
 108 static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
 109 {
 110     int cur, parent;
 111
 112     cur = ++(ti->heapnum);
 113     memcpy (ti->heap[ti->ptr[cur]], buf, ti->keysize);
 114     ti->indx[ti->ptr[cur]] = indx;
 115     parent = cur/2;
 116     while (parent && (*ti->cmp)(ti->heap[ti->ptr[parent]],
 117                                 ti->heap[ti->ptr[cur]]) > 0)
 118     {
 119         heap_swap (ti, cur, parent);
 120         cur = parent;
 121         parent = cur/2;
 122     }
 123 }
 124
 125 static struct trunc_info *heap_init (int size, int key_size,
 126                                      int (*cmp)(const void *p1,
 127                                                 const void *p2))
 128 {
 129     struct trunc_info *ti = xmalloc (sizeof(*ti));
 130     int i;
 131
 132     ++size;
 133     ti->heapnum = 0;
 134     ti->keysize = key_size;
 135     ti->cmp = cmp;
 136     ti->indx = xmalloc (size * sizeof(*ti->indx));
 137     ti->heap = xmalloc (size * sizeof(*ti->heap));
 138     ti->ptr = xmalloc (size * sizeof(*ti->ptr));
 139     ti->swapbuf = xmalloc (ti->keysize);
 140     ti->tmpbuf = xmalloc (ti->keysize);
 141     ti->buf = xmalloc (size * ti->keysize);
 142     for (i = size; --i >= 0; )
 143     {
 144         ti->ptr[i] = i;
 145         ti->heap[i] = ti->buf + ti->keysize * i;
 146     }
 147     return ti;
 148 }
 149
 150 static void heap_close (struct trunc_info *ti)
 151 {
 152     xfree (ti->ptr);
 153     xfree (ti->indx);
 154     xfree (ti->heap);
 155     xfree (ti->swapbuf);
 156     xfree (ti->tmpbuf);
 157     xfree (ti->buf);
 158     xfree (ti);
 159 }
 160
 161 static RSET rset_trunc_r (ZebraHandle zi, const char *term, int length,
 162                          const char *flags, ISAM_P *isam_p, int from, int to,
 163                          int merge_chunk)
 164 {
 165     RSET result;
 166     RSFD result_rsfd;
 167     rset_temp_parms parms;
 168
 169     parms.key_size = sizeof(struct it_key);
 170     parms.temp_path = res_get (zi->res, "setTmpDir");
 171     parms.rset_term = rset_term_create (term, length, flags);
 172     result = rset_create (rset_kind_temp, &parms);
 173     result_rsfd = rset_open (result, RSETF_WRITE);
 174
 175     if (to - from > merge_chunk)
 176     {
 177         RSFD *rsfd;
 178         RSET *rset;
 179         int term_index;
 180         int i, i_add = (to-from)/merge_chunk + 1;
 181         struct trunc_info *ti;
 182         int rscur = 0;
 183         int rsmax = (to-from)/i_add + 1;
 184
 185         rset = xmalloc (sizeof(*rset) * rsmax);
 186         rsfd = xmalloc (sizeof(*rsfd) * rsmax);
 187
 188         for (i = from; i < to; i += i_add)
 189         {
 190             if (i_add <= to - i)
 191                 rset[rscur] = rset_trunc_r (zi, term, length, flags,
 192                                             isam_p, i, i+i_add, merge_chunk);
 193             else
 194                 rset[rscur] = rset_trunc_r (zi, term, length, flags,
 195                                             isam_p, i, to, merge_chunk);
 196             rscur++;
 197         }
 198         ti = heap_init (rscur, sizeof(struct it_key), key_compare_it);
 199         for (i = rscur; --i >= 0; )
 200         {
 201             rsfd[i] = rset_open (rset[i], RSETF_READ);
 202             if (rset_read (rset[i], rsfd[i], ti->tmpbuf, &term_index))
 203                 heap_insert (ti, ti->tmpbuf, i);
 204             else
 205             {
 206                 rset_close (rset[i], rsfd[i]);
 207                 rset_delete (rset[i]);
 208             }
 209         }
 210         while (ti->heapnum)
 211         {
 212             int n = ti->indx[ti->ptr[1]];
 213
 214             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 215
 216             while (1)
 217             {
 218                 if (!rset_read (rset[n], rsfd[n], ti->tmpbuf, &term_index))
 219                 {
 220                     heap_delete (ti);
 221                     rset_close (rset[n], rsfd[n]);
 222                     rset_delete (rset[n]);
 223                     break;
 224                 }
 225                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 226                 {
 227                     heap_delete (ti);
 228                     heap_insert (ti, ti->tmpbuf, n);
 229                     break;
 230                 }
 231             }
 232         }
 233         xfree (rset);
 234         xfree (rsfd);
 235         heap_close (ti);
 236     }
 237     else if (zi->isam)
 238     {
 239         ISPT *ispt;
 240         int i;
 241         struct trunc_info *ti;
 242
 243         ispt = xmalloc (sizeof(*ispt) * (to-from));
 244
 245         ti = heap_init (to-from, sizeof(struct it_key),
 246                         key_compare_it);
 247         for (i = to-from; --i >= 0; )
 248         {
 249             ispt[i] = is_position (zi->isam, isam_p[from+i]);
 250             if (is_readkey (ispt[i], ti->tmpbuf))
 251                 heap_insert (ti, ti->tmpbuf, i);
 252             else
 253                 is_pt_free (ispt[i]);
 254         }
 255         while (ti->heapnum)
 256         {
 257             int n = ti->indx[ti->ptr[1]];
 258
 259             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 260 #if 1
 261 /* section that preserve all keys */
 262             heap_delete (ti);
 263             if (is_readkey (ispt[n], ti->tmpbuf))
 264                 heap_insert (ti, ti->tmpbuf, n);
 265             else
 266                 is_pt_free (ispt[n]);
 267 #else
 268 /* section that preserve all keys with unique sysnos */
 269             while (1)
 270             {
 271                 if (!is_readkey (ispt[n], ti->tmpbuf))
 272                 {
 273                     heap_delete (ti);
 274                     is_pt_free (ispt[n]);
 275                     break;
 276                 }
 277                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 278                 {
 279                     heap_delete (ti);
 280                     heap_insert (ti, ti->tmpbuf, n);
 281                     break;
 282                 }
 283             }
 284 #endif
 285         }
 286         heap_close (ti);
 287         xfree (ispt);
 288     }
 289     else
 290     {
 291         ISAMC_PP *ispt;
 292         int i;
 293         struct trunc_info *ti;
 294
 295         ispt = xmalloc (sizeof(*ispt) * (to-from));
 296
 297         ti = heap_init (to-from, sizeof(struct it_key),
 298                         key_compare_it);
 299         for (i = to-from; --i >= 0; )
 300         {
 301             ispt[i] = isc_pp_open (zi->isamc, isam_p[from+i]);
 302             if (isc_pp_read (ispt[i], ti->tmpbuf))
 303                 heap_insert (ti, ti->tmpbuf, i);
 304             else
 305                 isc_pp_close (ispt[i]);
 306         }
 307         while (ti->heapnum)
 308         {
 309             int n = ti->indx[ti->ptr[1]];
 310
 311             rset_write (result, result_rsfd, ti->heap[ti->ptr[1]]);
 312 #if 0
 313 /* section that preserve all keys */
 314             heap_delete (ti);
 315             if (is_readkey (ispt[n], ti->tmpbuf))
 316                 heap_insert (ti, ti->tmpbuf, n);
 317             else
 318                 isc_pp_close (ispt[n]);
 319 #else
 320 /* section that preserve all keys with unique sysnos */
 321             while (1)
 322             {
 323                 if (!isc_pp_read (ispt[n], ti->tmpbuf))
 324                 {
 325                     heap_delete (ti);
 326                     isc_pp_close (ispt[n]);
 327                     break;
 328                 }
 329                 if ((*ti->cmp)(ti->tmpbuf, ti->heap[ti->ptr[1]]) > 1)
 330                 {
 331                     heap_delete (ti);
 332                     heap_insert (ti, ti->tmpbuf, n);
 333                     break;
 334                 }
 335             }
 336 #endif
 337         }
 338         heap_close (ti);
 339         xfree (ispt);
 340     }
 341     rset_close (result, result_rsfd);
 342     return result;
 343 }
 344
 345 static int isam_trunc_cmp (const void *p1, const void *p2)
 346 {
 347     ISAM_P i1 = *(ISAM_P*) p1;
 348     ISAM_P i2 = *(ISAM_P*) p2;
 349     int d;
 350
 351     d = is_type (i1) - is_type (i2);
 352     if (d)
 353         return d;
 354     return is_block (i1) - is_block (i2);
 355 }
 356
 357 static int isamc_trunc_cmp (const void *p1, const void *p2)
 358 {
 359     ISAMC_P i1 = *(ISAMC_P*) p1;
 360     ISAMC_P i2 = *(ISAMC_P*) p2;
 361     int d;
 362
 363     d = isc_type (i1) - isc_type (i2);
 364     if (d)
 365         return d;
 366     return isc_block (i1) - isc_block (i2);
 367 }
 368
 369 RSET rset_trunc (ZebraHandle zi, ISAM_P *isam_p, int no,
 370                  const char *term, int length, const char *flags)
 371 {
 372     logf (LOG_DEBUG, "rset_trunc no=%d", no);
 373     if (zi->isam)
 374     {
 375         if (no < 1)
 376             return rset_create (rset_kind_null, NULL);
 377         else if (no == 1)
 378         {
 379             rset_isam_parms parms;
 380
 381             parms.pos = *isam_p;
 382             parms.is = zi->isam;
 383             parms.rset_term = rset_term_create (term, length, flags);
 384             return rset_create (rset_kind_isam, &parms);
 385         }
 386         qsort (isam_p, no, sizeof(*isam_p), isam_trunc_cmp);
 387     }
 388     else if (zi->isamc)
 389     {
 390         if (no < 1)
 391             return rset_create (rset_kind_null, NULL);
 392         else if (no == 1)
 393         {
 394             rset_isamc_parms parms;
 395
 396             parms.pos = *isam_p;
 397             parms.is = zi->isamc;
 398             parms.rset_term = rset_term_create (term, length, flags);
 399             return rset_create (rset_kind_isamc, &parms);
 400         }
 401 #if NEW_TRUNC
 402         else if (no < 200)
 403         {
 404             rset_m_or_parms parms;
 405
 406             parms.key_size = sizeof(struct it_key);
 407             parms.cmp = key_compare_it;
 408             parms.isc = zi->isamc;
 409             parms.isam_positions = isam_p;
 410             parms.no_isam_positions = no;
 411             parms.no_save_positions = 100000;
 412             parms.rset_term = rset_term_create (term, length, flags);
 413             return rset_create (rset_kind_m_or, &parms);
 414         }
 415 #endif
 416         qsort (isam_p, no, sizeof(*isam_p), isamc_trunc_cmp);
 417     }
 418     else
 419     {
 420         logf (LOG_WARN, "Neither isam nor isamc set in rset_trunc");
 421         return rset_create (rset_kind_null, NULL);
 422     }
 423     return rset_trunc_r (zi, term, length, flags, isam_p, 0, no, 100);
 424 }
 425