index/reckeys.c

   1 /* $Id: reckeys.c,v 1.13 2007-11-30 12:19:08 adam Exp $
   2    Copyright (C) 1995-2007
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <assert.h>
  27 #include <ctype.h>
  28
  29 #include "reckeys.h"
  30 #include <yaz/nmem.h>
  31 #include <yaz/xmalloc.h>
  32
  33 #define NEW 0
  34
  35 #if NEW
  36 struct zebra_rec_word_entry {
  37     char *buf;
  38     size_t len;
  39     int ord;
  40     int max_seq;
  41     struct zebra_rec_word_entry *next;
  42     struct zebra_rec_key_entry *keys;
  43     struct zebra_rec_key_entry **last_key;
  44 };
  45
  46 struct zebra_rec_key_entry {
  47     struct it_key key;
  48     struct zebra_rec_key_entry *next;
  49 };
  50 #else
  51 struct zebra_rec_key_entry {
  52     char *buf;
  53     size_t len;
  54     struct it_key key;
  55     struct zebra_rec_key_entry *next;
  56 };
  57 #endif
  58
  59 struct zebra_rec_keys_t_ {
  60     size_t buf_used;
  61     size_t buf_max;
  62     size_t fetch_offset;
  63     char *buf;
  64     void *encode_handle;
  65     void *decode_handle;
  66     char owner_of_buffer;
  67     zint custom_record_id;
  68
  69     NMEM nmem;
  70     size_t hash_size;
  71 #if NEW
  72     struct zebra_rec_word_entry **entries;
  73 #else
  74     struct zebra_rec_key_entry **entries;
  75 #endif
  76 };
  77
  78
  79 #if NEW
  80 struct zebra_rec_word_entry **zebra_rec_keys_mk_hash(zebra_rec_keys_t p,
  81                                                      const char *buf,
  82                                                      size_t len,
  83                                                      int ord)
  84 {
  85     int i;
  86     unsigned h = ord;
  87
  88     for (i = 0; i<len; i++)
  89         h = h * 65509 + buf[i];
  90     return &p->entries[h % (unsigned) p->hash_size];
  91 }
  92 #else
  93 struct zebra_rec_key_entry **zebra_rec_keys_mk_hash(zebra_rec_keys_t p,
  94                                                     const char *buf,
  95                                                     size_t len,
  96                                                     const struct it_key *key)
  97 {
  98     unsigned h = 0;
  99     size_t i;
 100     int j;
 101 #if 0
 102     h = key->mem[key->len-1];
 103 #else
 104     for (i = 0; i<len; i++)
 105         h = h * 65509 + buf[i];
 106     for (j = 0; j<key->len; j++)
 107         h = h * 65509 + CAST_ZINT_TO_INT(key->mem[j]);
 108 #endif
 109     return &p->entries[h % (unsigned) p->hash_size];
 110 }
 111 #endif
 112
 113 static void init_hash(zebra_rec_keys_t p)
 114 {
 115     p->entries = 0;
 116     nmem_reset(p->nmem);
 117     if (p->hash_size)
 118     {
 119         size_t i;
 120         p->entries = nmem_malloc(p->nmem, p->hash_size * sizeof(*p->entries));
 121         for (i = 0; i<p->hash_size; i++)
 122             p->entries[i] = 0;
 123     }
 124 }
 125
 126 zebra_rec_keys_t zebra_rec_keys_open(void)
 127 {
 128     zebra_rec_keys_t p = xmalloc(sizeof(*p));
 129     p->buf_used = 0;
 130     p->buf_max = 0;
 131     p->fetch_offset = 0;
 132     p->buf = 0;
 133     p->owner_of_buffer = 1;
 134     p->encode_handle = iscz1_start();
 135     p->decode_handle = iscz1_start();
 136
 137     p->custom_record_id = 0;
 138     p->nmem = nmem_create();
 139     p->hash_size = 32767;
 140     p->entries = 0;
 141
 142     init_hash(p);
 143
 144     return p;
 145 }
 146
 147 void zebra_rec_keys_set_buf(zebra_rec_keys_t p, char *buf, size_t sz,
 148                             int copy_buf)
 149 {
 150     if (p->owner_of_buffer)
 151         xfree(p->buf);
 152     p->buf_used = sz;
 153     p->buf_max = sz;
 154     if (!copy_buf)
 155     {
 156         p->buf = buf;
 157     }
 158     else
 159     {
 160         if (!sz)
 161             p->buf = 0;
 162         else
 163         {
 164             p->buf = xmalloc(sz);
 165             memcpy(p->buf, buf, sz);
 166         }
 167     }
 168     p->owner_of_buffer = copy_buf;
 169 }
 170
 171 void zebra_rec_keys_get_buf(zebra_rec_keys_t p, char **buf, size_t *sz)
 172 {
 173     *buf = p->buf;
 174     *sz = p->buf_used;
 175
 176     p->buf = 0;
 177     p->buf_max = 0;
 178     p->buf_used = 0;
 179 }
 180
 181 void zebra_rec_keys_close(zebra_rec_keys_t p)
 182 {
 183     if (!p)
 184         return;
 185
 186     if (p->owner_of_buffer)
 187         xfree(p->buf);
 188     if (p->encode_handle)
 189         iscz1_stop(p->encode_handle);
 190     if (p->decode_handle)
 191         iscz1_stop(p->decode_handle);
 192     nmem_destroy(p->nmem);
 193     xfree(p);
 194 }
 195
 196 #if NEW
 197 void zebra_rec_keys_write(zebra_rec_keys_t keys,
 198                           const char *str, size_t slen,
 199                           const struct it_key *key)
 200 {
 201     char *dst;
 202     const char *src = (char*) key;
 203
 204     struct zebra_rec_word_entry **wep;
 205     struct zebra_rec_key_entry **kep;
 206     int ord = key->mem[0];
 207     int seq = key->mem[key->len-1];
 208
 209     assert(keys->owner_of_buffer);
 210
 211     wep = zebra_rec_keys_mk_hash(keys, str, slen, ord);
 212
 213     while (*wep)
 214     {
 215         struct zebra_rec_word_entry *e = *wep;
 216         if (ord == e->ord && slen == e->len && !memcmp(str, e->buf, slen))
 217             break;
 218         wep = &(*wep)->next;
 219     }
 220
 221     if (!*wep)
 222     {
 223         *wep = nmem_malloc(keys->nmem, sizeof(**wep));
 224         (*wep)->buf = nmem_malloc(keys->nmem, slen);
 225         memcpy((*wep)->buf, str, slen);
 226         (*wep)->len = slen;
 227         (*wep)->ord = ord;
 228         (*wep)->next = 0;
 229         (*wep)->keys = 0;
 230         (*wep)->max_seq = 0;
 231         (*wep)->last_key = &(*wep)->keys;
 232     }
 233     if (seq > (*wep)->max_seq)
 234         kep = (*wep)->last_key;
 235     else
 236     {
 237         kep = &(*wep)->keys;
 238         while (*kep)
 239         {
 240             if (!key_compare(key, &(*kep)->key))
 241                 return;
 242             kep = &(*kep)->next;
 243         }
 244     }
 245     *kep = nmem_malloc(keys->nmem, sizeof(**kep));
 246     (*kep)->next = 0;
 247     (*wep)->last_key = &(*kep)->next;
 248     memcpy(&(*kep)->key, key, sizeof(*key));
 249     if (seq > (*wep)->max_seq)
 250     {
 251         (*wep)->max_seq = seq;
 252     }
 253 }
 254 #else
 255 int zebra_rec_keys_add_hash(zebra_rec_keys_t keys,
 256                             const char *str, size_t slen,
 257                             const struct it_key *key)
 258 {
 259     struct zebra_rec_key_entry **kep_first
 260         = zebra_rec_keys_mk_hash(keys, str, slen, key);
 261     struct zebra_rec_key_entry **kep = kep_first;
 262     while (*kep)
 263     {
 264         struct zebra_rec_key_entry *e = *kep;
 265         if (slen == e->len && !memcmp(str, e->buf, slen) &&
 266             !key_compare(key, &e->key))
 267         {
 268             *kep = (*kep)->next; /* out of queue */
 269             e->next = *kep_first; /* move to front */
 270             *kep_first = e;
 271
 272             return 0;
 273         }
 274         kep = &(*kep)->next;
 275     }
 276     *kep = nmem_malloc(keys->nmem, sizeof(**kep));
 277     (*kep)->next = 0;
 278     (*kep)->len = slen;
 279     memcpy(&(*kep)->key, key, sizeof(*key));
 280     (*kep)->buf = nmem_malloc(keys->nmem, slen);
 281     memcpy((*kep)->buf, str, slen);
 282     return 1;
 283 }
 284
 285 void zebra_rec_keys_write(zebra_rec_keys_t keys,
 286                           const char *str, size_t slen,
 287                           const struct it_key *key)
 288 {
 289     char *dst;
 290     const char *src = (char*) key;
 291
 292     assert(keys->owner_of_buffer);
 293
 294     if (key->mem[1]) /* record_id custom */
 295     {
 296         keys->custom_record_id = key->mem[1];
 297     }
 298 #if 1
 299     if (!zebra_rec_keys_add_hash(keys, str, slen, key))
 300     {
 301 #if 0
 302         yaz_log(YLOG_LOG, "dup key slen=%d %.*s "
 303                 "ord=" ZINT_FORMAT " seq=" ZINT_FORMAT,
 304                 slen, slen, str, key->mem[0], key->mem[key->len-1]);
 305 #endif
 306         return;  /* key already there . Omit it */
 307     }
 308 #endif
 309     if (keys->buf_used+1024 > keys->buf_max)
 310     {
 311         char *b = (char *) xmalloc (keys->buf_max += 128000);
 312         if (keys->buf_used > 0)
 313             memcpy (b, keys->buf, keys->buf_used);
 314         xfree (keys->buf);
 315         keys->buf = b;
 316     }
 317     dst = keys->buf + keys->buf_used;
 318
 319     iscz1_encode(keys->encode_handle, &dst, &src);
 320
 321     memcpy (dst, str, slen);
 322     dst += slen;
 323     *dst++ = '\0';
 324     keys->buf_used = dst - keys->buf;
 325 }
 326 #endif
 327
 328 void zebra_rec_keys_reset(zebra_rec_keys_t keys)
 329 {
 330     assert(keys);
 331     keys->buf_used = 0;
 332
 333     iscz1_reset(keys->encode_handle);
 334
 335     init_hash(keys);
 336 }
 337
 338 int zebra_rec_keys_rewind(zebra_rec_keys_t keys)
 339 {
 340     assert(keys);
 341     iscz1_reset(keys->decode_handle);
 342
 343 #if NEW
 344     if (keys->buf_used == 0)
 345     {
 346         size_t i;
 347         for (i = 0; i<keys->hash_size; i++)
 348         {
 349             struct zebra_rec_word_entry *we = keys->entries[i];
 350             for (; we; we = we->next)
 351             {
 352                 struct zebra_rec_key_entry *ke = we->keys;
 353                 for (; ke; ke = ke->next)
 354                 {
 355                     const char *src = (char*) &ke->key;
 356                     char *dst;
 357                     if (keys->buf_used+1024 > keys->buf_max)
 358                     {
 359                         char *b = (char *) xmalloc (keys->buf_max += 128000);
 360                         if (keys->buf_used > 0)
 361                             memcpy (b, keys->buf, keys->buf_used);
 362                         xfree (keys->buf);
 363                         keys->buf = b;
 364                     }
 365
 366                     dst = keys->buf + keys->buf_used;
 367
 368                     iscz1_encode(keys->encode_handle, &dst, &src);
 369
 370                     memcpy (dst, we->buf, we->len);
 371                     dst += we->len;
 372                     *dst++ = '\0';
 373                     keys->buf_used = dst - keys->buf;
 374                 }
 375             }
 376         }
 377     }
 378 #endif
 379
 380     keys->fetch_offset = 0;
 381     if (keys->buf_used == 0)
 382         return 0;
 383     return 1;
 384 }
 385
 386 int zebra_rec_keys_empty(zebra_rec_keys_t keys)
 387 {
 388     if (keys->buf_used == 0)
 389         return 1;
 390     return 0;
 391 }
 392
 393 int zebra_rec_keys_read(zebra_rec_keys_t keys,
 394                         const char **str, size_t *slen,
 395                         struct it_key *key)
 396 {
 397     assert(keys);
 398     if (keys->fetch_offset == keys->buf_used)
 399         return 0;
 400     else
 401     {
 402         const char *src = keys->buf + keys->fetch_offset;
 403         char *dst = (char*) key;
 404
 405         assert (keys->fetch_offset < keys->buf_used);
 406
 407         /* store the destination key */
 408         iscz1_decode(keys->decode_handle, &dst, &src);
 409
 410         /* store pointer to string and length of it */
 411         *str = src;
 412         *slen = strlen(src);
 413         src += *slen + 1;
 414
 415         keys->fetch_offset = src - keys->buf;
 416     }
 417     return 1;
 418 }
 419
 420 zint zebra_rec_keys_get_custom_record_id(zebra_rec_keys_t keys)
 421 {
 422     return keys->custom_record_id;
 423 }
 424
 425 /*
 426  * Local variables:
 427  * c-basic-offset: 4
 428  * indent-tabs-mode: nil
 429  * End:
 430  * vim: shiftwidth=4 tabstop=8 expandtab
 431  */
 432