index/recindex.c

   1 /* This file is part of the Zebra server.
   2    Copyright (C) 1994-2011 Index Data
   3
   4 Zebra is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <assert.h>
  23 #include <string.h>
  24
  25 #include <idzebra/isamb.h>
  26 #include <yaz/yaz-util.h>
  27 #include "recindex.h"
  28
  29 #define RIDX_CHUNK 128
  30
  31
  32 struct recindex {
  33     char *index_fname;
  34     BFile index_BFile;
  35     ISAMB isamb;
  36     ISAM_P isam_p;
  37 };
  38
  39 struct record_index_entry {
  40     zint next;         /* first block of record info / next free entry */
  41     int size;          /* size of record or 0 if free entry */
  42 } ent;
  43
  44
  45 static void rect_log_item(int level, const void *b, const char *txt)
  46 {
  47     zint sys;
  48     int len;
  49
  50
  51     memcpy(&sys, b, sizeof(sys));
  52     len = ((const char *) b)[sizeof(sys)];
  53
  54     if (len == sizeof(struct record_index_entry))
  55     {
  56         memcpy(&ent, (const char *)b + sizeof(sys) + 1, len);
  57         yaz_log(YLOG_LOG, "%s " ZINT_FORMAT " next=" ZINT_FORMAT " sz=%d", txt, sys,
  58                 ent.next, ent.size);
  59
  60     }
  61     else
  62         yaz_log(YLOG_LOG, "%s " ZINT_FORMAT, txt, sys);
  63 }
  64
  65 int rect_compare(const void *a, const void *b)
  66 {
  67     zint s_a, s_b;
  68
  69     memcpy(&s_a, a, sizeof(s_a));
  70     memcpy(&s_b, b, sizeof(s_b));
  71
  72     if (s_a > s_b)
  73         return 1;
  74     else if (s_a < s_b)
  75         return -1;
  76     return 0;
  77 }
  78
  79 void *rect_code_start(void)
  80 {
  81     return 0;
  82 }
  83
  84 void rect_encode(void *p, char **dst, const char **src)
  85 {
  86     zint sys;
  87     int len;
  88
  89     memcpy(&sys, *src, sizeof(sys));
  90     zebra_zint_encode(dst, sys);
  91     (*src) += sizeof(sys);
  92
  93     len = **src;
  94     **dst = len;
  95     (*src)++;
  96     (*dst)++;
  97
  98     memcpy(*dst, *src, len);
  99     *dst += len;
 100     *src += len;
 101 }
 102
 103 void rect_decode(void *p, char **dst, const char **src)
 104 {
 105     zint sys;
 106     int len;
 107
 108     zebra_zint_decode(src, &sys);
 109     memcpy(*dst, &sys, sizeof(sys));
 110     *dst += sizeof(sys);
 111
 112     len = **src;
 113     **dst = len;
 114     (*src)++;
 115     (*dst)++;
 116
 117     memcpy(*dst, *src, len);
 118     *dst += len;
 119     *src += len;
 120 }
 121
 122 void rect_code_reset(void *p)
 123 {
 124 }
 125
 126 void rect_code_stop(void *p)
 127 {
 128 }
 129
 130
 131 recindex_t recindex_open(BFiles bfs, int rw, int use_isamb)
 132 {
 133     recindex_t p = xmalloc(sizeof(*p));
 134     p->index_BFile = 0;
 135     p->isamb = 0;
 136
 137     p->index_fname = "reci";
 138     p->index_BFile = bf_open(bfs, p->index_fname, RIDX_CHUNK, rw);
 139     if (p->index_BFile == NULL)
 140     {
 141         yaz_log(YLOG_FATAL|YLOG_ERRNO, "open %s", p->index_fname);
 142         xfree(p);
 143         return 0;
 144     }
 145
 146     if (use_isamb)
 147     {
 148         int isam_block_size = 4096;
 149         ISAMC_M method;
 150
 151         method.compare_item = rect_compare;
 152         method.log_item = rect_log_item;
 153         method.codec.start = rect_code_start;
 154         method.codec.encode = rect_encode;
 155         method.codec.decode = rect_decode;
 156         method.codec.reset = rect_code_reset;
 157         method.codec.stop = rect_code_stop;
 158
 159         p->index_fname = "rect";
 160         p->isamb = isamb_open2(bfs, p->index_fname, rw, &method,
 161                                /* cache */ 0,
 162                                /* no_cat */ 1, &isam_block_size,
 163                                /* use_root_ptr */ 1);
 164
 165         p->isam_p = 0;
 166         if (p->isamb)
 167             p->isam_p = isamb_get_root_ptr(p->isamb);
 168
 169     }
 170     return p;
 171 }
 172
 173 static void log_pr(const char *txt)
 174 {
 175     yaz_log(YLOG_LOG, "%s", txt);
 176 }
 177
 178
 179 void recindex_close(recindex_t p)
 180 {
 181     if (p)
 182     {
 183         if (p->index_BFile)
 184             bf_close(p->index_BFile);
 185         if (p->isamb)
 186         {
 187             isamb_set_root_ptr(p->isamb, p->isam_p);
 188             isamb_dump(p->isamb, p->isam_p, log_pr);
 189             isamb_close(p->isamb);
 190         }
 191         xfree(p);
 192     }
 193 }
 194
 195 int recindex_read_head(recindex_t p, void *buf)
 196 {
 197     return bf_read(p->index_BFile, 0, 0, 0, buf);
 198 }
 199
 200 const char *recindex_get_fname(recindex_t p)
 201 {
 202     return p->index_fname;
 203 }
 204
 205 ZEBRA_RES recindex_write_head(recindex_t p, const void *buf, size_t len)
 206 {
 207     int r;
 208
 209     assert(p);
 210
 211     assert(p->index_BFile);
 212
 213     r = bf_write(p->index_BFile, 0, 0, len, buf);
 214     if (r)
 215     {
 216         yaz_log(YLOG_FATAL|YLOG_ERRNO, "write head of %s", p->index_fname);
 217         return ZEBRA_FAIL;
 218     }
 219     return ZEBRA_OK;
 220 }
 221
 222 int recindex_read_indx(recindex_t p, zint sysno, void *buf, int itemsize,
 223                        int ignoreError)
 224 {
 225     int r = 0;
 226     if (p->isamb)
 227     {
 228         if (p->isam_p)
 229         {
 230             char item[256];
 231             char *st = item;
 232             char untilbuf[sizeof(zint) + 1];
 233
 234             ISAMB_PP isam_pp = isamb_pp_open(p->isamb, p->isam_p, 1);
 235
 236             memcpy(untilbuf, &sysno, sizeof(sysno));
 237             untilbuf[sizeof(sysno)] = 0;
 238             r = isamb_pp_forward(isam_pp, st, untilbuf);
 239
 240             isamb_pp_close(isam_pp);
 241             if (!r)
 242                 return 0;
 243
 244             if (item[sizeof(sysno)] != itemsize)
 245             {
 246                 yaz_log(YLOG_WARN, "unexpected entry size %d != %d",
 247                         item[sizeof(sysno)], itemsize);
 248                 return 0;
 249             }
 250             memcpy(buf, item + sizeof(sysno) + 1, itemsize);
 251         }
 252     }
 253     else
 254     {
 255         zint pos = (sysno-1)*itemsize;
 256         int off = CAST_ZINT_TO_INT(pos%RIDX_CHUNK);
 257         int sz1 = RIDX_CHUNK - off;    /* sz1 is size of buffer to read.. */
 258
 259         if (sz1 > itemsize)
 260             sz1 = itemsize;  /* no more than itemsize bytes */
 261
 262         r = bf_read(p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf);
 263         if (r == 1 && sz1 < itemsize) /* boundary? - must read second part */
 264             r = bf_read(p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1,
 265                         (char*) buf + sz1);
 266         if (r != 1 && !ignoreError)
 267         {
 268             yaz_log(YLOG_FATAL|YLOG_ERRNO, "read in %s at pos %ld",
 269                     p->index_fname, (long) pos);
 270         }
 271     }
 272 #if 0
 273     {
 274         struct record_index_entry *ep = buf;
 275         yaz_log(YLOG_LOG, "read r=%d sysno=" ZINT_FORMAT " next=" ZINT_FORMAT
 276             " sz=%d", r, sysno, ep->next, ep->size);
 277     }
 278 #endif
 279     return r;
 280 }
 281
 282 struct code_read_data {
 283     int no;
 284     zint sysno;
 285     void *buf;
 286     int itemsize;
 287     int insert_flag;
 288 };
 289
 290 int bt_code_read(void *vp, char **dst, int *insertMode)
 291 {
 292     struct code_read_data *s = (struct code_read_data *) vp;
 293
 294     if (s->no == 0)
 295         return 0;
 296
 297     (s->no)--;
 298
 299     memcpy(*dst, &s->sysno, sizeof(zint));
 300     *dst += sizeof(zint);
 301     **dst = s->itemsize;
 302     (*dst)++;
 303     memcpy(*dst, s->buf, s->itemsize);
 304     *dst += s->itemsize;
 305     *insertMode = s->insert_flag;
 306     return 1;
 307 }
 308
 309 void recindex_write_indx(recindex_t p, zint sysno, void *buf, int itemsize)
 310 {
 311 #if 0
 312     yaz_log(YLOG_LOG, "write_indx sysno=" ZINT_FORMAT, sysno);
 313 #endif
 314     if (p->isamb)
 315     {
 316         struct code_read_data input;
 317         ISAMC_I isamc_i;
 318
 319         input.sysno = sysno;
 320         input.buf = buf;
 321         input.itemsize = itemsize;
 322
 323         isamc_i.clientData = &input;
 324         isamc_i.read_item = bt_code_read;
 325
 326         input.no = 1;
 327         input.insert_flag = 2;
 328         isamb_merge(p->isamb, &p->isam_p, &isamc_i);
 329     }
 330     else
 331     {
 332         zint pos = (sysno-1)*itemsize;
 333         int off = CAST_ZINT_TO_INT(pos%RIDX_CHUNK);
 334         int sz1 = RIDX_CHUNK - off;    /* sz1 is size of buffer to read.. */
 335
 336         if (sz1 > itemsize)
 337             sz1 = itemsize;  /* no more than itemsize bytes */
 338
 339         bf_write(p->index_BFile, 1+pos/RIDX_CHUNK, off, sz1, buf);
 340         if (sz1 < itemsize)   /* boundary? must write second part */
 341             bf_write(p->index_BFile, 2+pos/RIDX_CHUNK, 0, itemsize - sz1,
 342                      (char*) buf + sz1);
 343     }
 344 }
 345
 346
 347 /*
 348  * Local variables:
 349  * c-basic-offset: 4
 350  * c-file-style: "Stroustrup"
 351  * indent-tabs-mode: nil
 352  * End:
 353  * vim: shiftwidth=4 tabstop=8 expandtab
 354  */
 355