isams/isams.c

   1 /* $Id: isams.c,v 1.11 2005-01-15 19:38:31 adam Exp $
   2    Copyright (C) 1995-2005
   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 Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24 #include <stdlib.h>
  25 #include <assert.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28
  29 #include <yaz/log.h>
  30 #include <yaz/xmalloc.h>
  31 #include <idzebra/isams.h>
  32
  33 typedef struct {
  34     int last_offset;
  35     int last_block;
  36 } ISAMS_head;
  37
  38 typedef unsigned ISAMS_BLOCK_SIZE;
  39
  40 struct ISAMS_s {
  41     ISAMS_M *method;
  42     ISAMS_head head;
  43     ISAMS_head head_old;
  44     char *merge_buf;
  45
  46     int block_size;
  47     int debug;
  48     BFile bf;
  49 };
  50
  51 struct ISAMS_PP_s {
  52     ISAMS is;
  53     char *buf;
  54     int block_offset;
  55     int block_no;
  56     void *decodeClientData;
  57     int numKeys;
  58     int numRead;
  59 };
  60
  61 void isams_getmethod (ISAMS_M *m)
  62 {
  63     m->codec.start = NULL;
  64     m->codec.decode = NULL;
  65     m->codec.encode = NULL;
  66     m->codec.stop = NULL;
  67     m->codec.reset = NULL;
  68
  69     m->compare_item = NULL;
  70     m->log_item = NULL;
  71
  72     m->debug = 1;
  73     m->block_size = 128;
  74 }
  75
  76 ISAMS isams_open (BFiles bfs, const char *name, int writeflag,
  77                   ISAMS_M *method)
  78 {
  79     ISAMS is = (ISAMS) xmalloc (sizeof(*is));
  80
  81     is->method = (ISAMS_M *) xmalloc (sizeof(*is->method));
  82     memcpy (is->method, method, sizeof(*method));
  83     is->block_size = is->method->block_size;
  84     is->debug = is->method->debug;
  85
  86     is->bf = bf_open (bfs, name, is->block_size, writeflag);
  87
  88     if (!bf_read (is->bf, 0, 0, sizeof(ISAMS_head), &is->head))
  89     {
  90         is->head.last_block = 1;
  91         is->head.last_offset = 0;
  92     }
  93     memcpy (&is->head_old, &is->head, sizeof(is->head));
  94     is->merge_buf = (char *) xmalloc(2*is->block_size);
  95     memset(is->merge_buf, 0, 2*is->block_size);
  96     return is;
  97 }
  98
  99 int isams_close (ISAMS is)
 100 {
 101     if (memcmp(&is->head, &is->head_old, sizeof(is->head)))
 102     {
 103         if (is->head.last_offset)
 104             bf_write(is->bf, is->head.last_block, 0, is->head.last_offset,
 105                      is->merge_buf);
 106         bf_write (is->bf, 0, 0, sizeof(is->head), &is->head);
 107     }
 108     bf_close (is->bf);
 109     xfree (is->merge_buf);
 110     xfree (is->method);
 111     xfree (is);
 112     return 0;
 113 }
 114
 115 ISAMS_P isams_merge (ISAMS is, ISAMS_I data)
 116 {
 117     char i_item[128];
 118     int i_more, i_mode;
 119     void *r_clientData;
 120     int first_block = is->head.last_block;
 121     int first_offset = is->head.last_offset;
 122     int count = 0;
 123
 124     r_clientData = (*is->method->codec.start)();
 125
 126     is->head.last_offset += sizeof(int);
 127     if (is->head.last_offset > is->block_size)
 128     {
 129         if (is->debug > 2)
 130             yaz_log (YLOG_LOG, "first_block=%d", first_block);
 131         bf_write(is->bf, is->head.last_block, 0, 0, is->merge_buf);
 132         (is->head.last_block)++;
 133         is->head.last_offset -= is->block_size;
 134         memcpy (is->merge_buf, is->merge_buf + is->block_size,
 135                 is->head.last_offset);
 136     }
 137     while (1)
 138     {
 139         char *tmp_ptr = i_item;
 140         i_more = (*data->read_item)(data->clientData, &tmp_ptr, &i_mode);
 141         assert (i_mode);
 142
 143         if (!i_more)
 144             break;
 145         else
 146         {
 147             char *r_out_ptr = is->merge_buf + is->head.last_offset;
 148
 149             const char *i_item_ptr = i_item;
 150             (*is->method->codec.encode)(r_clientData, &r_out_ptr, &i_item_ptr);
 151             is->head.last_offset = r_out_ptr - is->merge_buf;
 152             if (is->head.last_offset > is->block_size)
 153             {
 154                 bf_write(is->bf, is->head.last_block, 0, 0, is->merge_buf);
 155                 (is->head.last_block)++;
 156                 is->head.last_offset -= is->block_size;
 157                 memcpy (is->merge_buf, is->merge_buf + is->block_size,
 158                         is->head.last_offset);
 159             }
 160             count++;
 161         }
 162     }
 163     (*is->method->codec.stop)(r_clientData);
 164     if (first_block == is->head.last_block)
 165         memcpy(is->merge_buf + first_offset, &count, sizeof(int));
 166     else if (first_block == is->head.last_block-1)
 167     {
 168         int gap = first_offset + sizeof(int) - is->block_size;
 169         assert (gap <= (int) sizeof(int));
 170         if (gap > 0)
 171         {
 172             if (gap < (int) sizeof(int))
 173                 bf_write(is->bf, first_block, first_offset, sizeof(int)-gap,
 174                          &count);
 175             memcpy (is->merge_buf, ((char*)&count)+(sizeof(int)-gap), gap);
 176         }
 177         else
 178             bf_write(is->bf, first_block, first_offset, sizeof(int), &count);
 179     }
 180     else
 181     {
 182         bf_write(is->bf, first_block, first_offset, sizeof(int), &count);
 183     }
 184     return first_block * is->block_size + first_offset;
 185 }
 186
 187 ISAMS_PP isams_pp_open (ISAMS is, ISAMS_P pos)
 188 {
 189     ISAMS_PP pp = (ISAMS_PP) xmalloc (sizeof(*pp));
 190
 191     if (is->debug > 1)
 192         yaz_log (YLOG_LOG, "isams: isams_pp_open pos=%ld", (long) pos);
 193     pp->is = is;
 194     pp->decodeClientData = (*is->method->codec.start)();
 195     pp->numKeys = 0;
 196     pp->numRead = 0;
 197     pp->buf = (char *) xmalloc(is->block_size*2);
 198     pp->block_no = (int) (pos/is->block_size);
 199     pp->block_offset = (int) (pos - pp->block_no * is->block_size);
 200     if (is->debug)
 201         yaz_log (YLOG_LOG, "isams: isams_pp_open off=%d no=%d",
 202               pp->block_offset, pp->block_no);
 203     if (pos)
 204     {
 205         bf_read (is->bf, pp->block_no, 0, 0, pp->buf);
 206         bf_read (is->bf, pp->block_no+1, 0, 0, pp->buf + is->block_size);
 207         memcpy(&pp->numKeys, pp->buf + pp->block_offset, sizeof(int));
 208         if (is->debug)
 209             yaz_log (YLOG_LOG, "isams: isams_pp_open numKeys=%d", pp->numKeys);
 210         pp->block_offset += sizeof(int);
 211     }
 212     return pp;
 213 }
 214
 215 void isams_pp_close (ISAMS_PP pp)
 216 {
 217     (*pp->is->method->codec.stop)(pp->decodeClientData);
 218     xfree(pp->buf);
 219     xfree(pp);
 220 }
 221
 222 int isams_pp_num (ISAMS_PP pp)
 223 {
 224     return pp->numKeys;
 225 }
 226
 227 int isams_pp_read (ISAMS_PP pp, void *buf)
 228 {
 229     char *cp = buf;
 230     return isams_read_item (pp, &cp);
 231 }
 232
 233 int isams_read_item (ISAMS_PP pp, char **dst)
 234 {
 235     const char *src;
 236     if (pp->numRead >= pp->numKeys)
 237         return 0;
 238     (pp->numRead)++;
 239     if (pp->block_offset > pp->is->block_size)
 240     {
 241         pp->block_offset -= pp->is->block_size;
 242         (pp->block_no)++;
 243         memcpy (pp->buf, pp->buf + pp->is->block_size, pp->is->block_size);
 244         bf_read (pp->is->bf, pp->block_no+1, 0, 0,
 245                  pp->buf + pp->is->block_size);
 246     }
 247     src = pp->buf + pp->block_offset;
 248     (*pp->is->method->codec.decode)(pp->decodeClientData, dst, &src);
 249     pp->block_offset = src - pp->buf;
 250     return 1;
 251 }
 252
 253