index/extract.c

   1 /* $Id: extract.c,v 1.197 2005-10-28 09:22:50 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 #include <stdio.h>
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #ifdef WIN32
  27 #include <io.h>
  28 #endif
  29 #if HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32 #include <fcntl.h>
  33
  34 #include "index.h"
  35 #include <direntz.h>
  36 #include <charmap.h>
  37
  38 #if _FILE_OFFSET_BITS == 64
  39 #define PRINTF_OFF_T "%Ld"
  40 #else
  41 #define PRINTF_OFF_T "%ld"
  42 #endif
  43
  44 #define USE_SHELLSORT 0
  45
  46 #if USE_SHELLSORT
  47 static void shellsort(void *ar, int r, size_t s,
  48                       int (*cmp)(const void *a, const void *b))
  49 {
  50     char *a = ar;
  51     char v[100];
  52     int h, i, j, k;
  53     static const int incs[16] = { 1391376, 463792, 198768, 86961, 33936,
  54                                   13776, 4592, 1968, 861, 336,
  55                                   112, 48, 21, 7, 3, 1 };
  56     for ( k = 0; k < 16; k++)
  57         for (h = incs[k], i = h; i < r; i++)
  58         {
  59             memcpy (v, a+s*i, s);
  60             j = i;
  61             while (j > h && (*cmp)(a + s*(j-h), v) > 0)
  62             {
  63                 memcpy (a + s*j, a + s*(j-h), s);
  64                 j -= h;
  65             }
  66             memcpy (a+s*j, v, s);
  67         }
  68 }
  69 #endif
  70
  71 static void logRecord (ZebraHandle zh)
  72 {
  73     ++zh->records_processed;
  74     if (!(zh->records_processed % 1000))
  75     {
  76         yaz_log (YLOG_LOG, "Records: "ZINT_FORMAT" i/u/d "
  77                         ZINT_FORMAT"/"ZINT_FORMAT"/"ZINT_FORMAT,
  78               zh->records_processed, zh->records_inserted, zh->records_updated,
  79               zh->records_deleted);
  80     }
  81 }
  82
  83 static void extract_set_store_data_prepare(struct recExtractCtrl *p);
  84
  85 static void extract_init (struct recExtractCtrl *p, RecWord *w)
  86 {
  87     w->zebra_maps = p->zebra_maps;
  88     w->seqno = 1;
  89 #if NATTR
  90 #else
  91     w->attrSet = VAL_BIB1;
  92     w->attrUse = 1016;
  93 #endif
  94     w->index_name = 0;
  95     w->index_type = 'w';
  96     w->extractCtrl = p;
  97     w->record_id = 0;
  98     w->section_id = 0;
  99 }
 100
 101 static void searchRecordKey(ZebraHandle zh,
 102                             zebra_rec_keys_t reckeys,
 103                             int attrSetS, int attrUseS,
 104                             const char **ws, int ws_length)
 105 {
 106     int i;
 107     int ch;
 108
 109     for (i = 0; i<ws_length; i++)
 110         ws[i] = NULL;
 111
 112     ch = zebraExplain_lookup_attr_su_any_index(zh->reg->zei,
 113                                                attrSetS, attrUseS);
 114     if (ch < 0)
 115         return ;
 116
 117     if (zebra_rec_keys_rewind(reckeys))
 118     {
 119         int startSeq = -1;
 120         const char *str;
 121         size_t slen;
 122         struct it_key key;
 123         zint seqno;
 124         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
 125         {
 126             assert(key.len <= 4 && key.len > 2);
 127
 128             seqno = key.mem[key.len-1];
 129
 130             if (key.mem[0] == ch)
 131             {
 132                 int woff;
 133
 134                 if (startSeq == -1)
 135                     startSeq = seqno;
 136                 woff = seqno - startSeq;
 137                 if (woff >= 0 && woff < ws_length)
 138                     ws[woff] = str;
 139             }
 140         }
 141     }
 142 }
 143
 144 struct file_read_info {
 145     off_t file_max;         /* maximum offset so far */
 146     off_t file_offset;      /* current offset */
 147     off_t file_moffset;     /* offset of rec/rec boundary */
 148     int file_more;
 149     int fd;
 150 };
 151
 152 static struct file_read_info *file_read_start (int fd)
 153 {
 154     struct file_read_info *fi = (struct file_read_info *)
 155         xmalloc (sizeof(*fi));
 156
 157     fi->fd = fd;
 158     fi->file_max = 0;
 159     fi->file_moffset = 0;
 160     fi->file_offset = 0;
 161     fi->file_more = 0;
 162     return fi;
 163 }
 164
 165 static void file_read_stop (struct file_read_info *fi)
 166 {
 167     xfree (fi);
 168 }
 169
 170 static off_t file_seek (void *handle, off_t offset)
 171 {
 172     struct file_read_info *p = (struct file_read_info *) handle;
 173     p->file_offset = offset;
 174     return lseek (p->fd, offset, SEEK_SET);
 175 }
 176
 177 static off_t file_tell (void *handle)
 178 {
 179     struct file_read_info *p = (struct file_read_info *) handle;
 180     return p->file_offset;
 181 }
 182
 183 static int file_read (void *handle, char *buf, size_t count)
 184 {
 185     struct file_read_info *p = (struct file_read_info *) handle;
 186     int fd = p->fd;
 187     int r;
 188     r = read (fd, buf, count);
 189     if (r > 0)
 190     {
 191         p->file_offset += r;
 192         if (p->file_offset > p->file_max)
 193             p->file_max = p->file_offset;
 194     }
 195     return r;
 196 }
 197
 198 static void file_end (void *handle, off_t offset)
 199 {
 200     struct file_read_info *p = (struct file_read_info *) handle;
 201
 202     if (offset != p->file_moffset)
 203     {
 204         p->file_moffset = offset;
 205         p->file_more = 1;
 206     }
 207 }
 208
 209 static char *fileMatchStr (ZebraHandle zh,
 210                            zebra_rec_keys_t reckeys,
 211                            const char *fname, const char *spec)
 212 {
 213     static char dstBuf[2048];      /* static here ??? */
 214     char *dst = dstBuf;
 215     const char *s = spec;
 216
 217     while (1)
 218     {
 219         while (*s == ' ' || *s == '\t')
 220             s++;
 221         if (!*s)
 222             break;
 223         if (*s == '(')
 224         {
 225             const char *ws[32];
 226             char attset_str[64], attname_str[64];
 227             data1_attset *attset;
 228             int i;
 229             char matchFlag[32];
 230             int attSet = 1, attUse = 1;
 231             int first = 1;
 232
 233             s++;
 234             for (i = 0; *s && *s != ',' && *s != ')'; s++)
 235                 if (i < 63)
 236                     attset_str[i++] = *s;
 237             attset_str[i] = '\0';
 238
 239             if (*s == ',')
 240             {
 241                 s++;
 242                 for (i = 0; *s && *s != ')'; s++)
 243                     if (i < 63)
 244                         attname_str[i++] = *s;
 245                 attname_str[i] = '\0';
 246             }
 247
 248             if ((attset = data1_get_attset (zh->reg->dh, attset_str)))
 249             {
 250                 data1_att *att;
 251                 attSet = attset->reference;
 252                 att = data1_getattbyname(zh->reg->dh, attset, attname_str);
 253                 if (att)
 254                     attUse = att->value;
 255                 else
 256                     attUse = atoi (attname_str);
 257             }
 258             searchRecordKey (zh, reckeys, attSet, attUse, ws, 32);
 259
 260             if (*s == ')')
 261             {
 262                 for (i = 0; i<32; i++)
 263                     matchFlag[i] = 1;
 264             }
 265             else
 266             {
 267                 yaz_log (YLOG_WARN, "Missing ) in match criteria %s in group %s",
 268                       spec, zh->m_group ? zh->m_group : "none");
 269                 return NULL;
 270             }
 271             s++;
 272
 273             for (i = 0; i<32; i++)
 274                 if (matchFlag[i] && ws[i])
 275                 {
 276                     if (first)
 277                     {
 278                         *dst++ = ' ';
 279                         first = 0;
 280                     }
 281                     strcpy (dst, ws[i]);
 282                     dst += strlen(ws[i]);
 283                 }
 284             if (first)
 285             {
 286                 yaz_log (YLOG_WARN, "Record didn't contain match"
 287                       " fields in (%s,%s)", attset_str, attname_str);
 288                 return NULL;
 289             }
 290         }
 291         else if (*s == '$')
 292         {
 293             int spec_len;
 294             char special[64];
 295             const char *spec_src = NULL;
 296             const char *s1 = ++s;
 297             while (*s1 && *s1 != ' ' && *s1 != '\t')
 298                 s1++;
 299
 300             spec_len = s1 - s;
 301             if (spec_len > 63)
 302                 spec_len = 63;
 303             memcpy (special, s, spec_len);
 304             special[spec_len] = '\0';
 305             s = s1;
 306
 307             if (!strcmp (special, "group"))
 308                 spec_src = zh->m_group;
 309             else if (!strcmp (special, "database"))
 310                 spec_src = zh->basenames[0];
 311             else if (!strcmp (special, "filename")) {
 312                 spec_src = fname;
 313             }
 314             else if (!strcmp (special, "type"))
 315                 spec_src = zh->m_record_type;
 316             else
 317                 spec_src = NULL;
 318             if (spec_src)
 319             {
 320                 strcpy (dst, spec_src);
 321                 dst += strlen (spec_src);
 322             }
 323         }
 324         else if (*s == '\"' || *s == '\'')
 325         {
 326             int stopMarker = *s++;
 327             char tmpString[64];
 328             int i = 0;
 329
 330             while (*s && *s != stopMarker)
 331             {
 332                 if (i < 63)
 333                     tmpString[i++] = *s++;
 334             }
 335             if (*s)
 336                 s++;
 337             tmpString[i] = '\0';
 338             strcpy (dst, tmpString);
 339             dst += strlen (tmpString);
 340         }
 341         else
 342         {
 343             yaz_log (YLOG_WARN, "Syntax error in match criteria %s in group %s",
 344                   spec, zh->m_group ? zh->m_group : "none");
 345             return NULL;
 346         }
 347         *dst++ = 1;
 348     }
 349     if (dst == dstBuf)
 350     {
 351         yaz_log (YLOG_WARN, "No match criteria for record %s in group %s",
 352               fname, zh->m_group ? zh->m_group : "none");
 353         return NULL;
 354     }
 355     *dst = '\0';
 356     return dstBuf;
 357 }
 358
 359 struct recordLogInfo {
 360     const char *fname;
 361     int recordOffset;
 362     struct recordGroup *rGroup;
 363 };
 364
 365 static void init_extractCtrl(ZebraHandle zh, struct recExtractCtrl *ctrl)
 366 {
 367     int i;
 368     for (i = 0; i<256; i++)
 369     {
 370         if (zebra_maps_is_positioned(zh->reg->zebra_maps, i))
 371             ctrl->seqno[i] = 1;
 372         else
 373             ctrl->seqno[i] = 0;
 374     }
 375     ctrl->zebra_maps = zh->reg->zebra_maps;
 376     ctrl->flagShowRecords = !zh->m_flag_rw;
 377 }
 378
 379 static int file_extract_record(ZebraHandle zh,
 380                                SYSNO *sysno, const char *fname,
 381                                int deleteFlag,
 382                                struct file_read_info *fi,
 383                                int force_update,
 384                                RecType recType,
 385                                void *recTypeClientData)
 386 {
 387     RecordAttr *recordAttr;
 388     int r;
 389     const char *matchStr = 0;
 390     SYSNO sysnotmp;
 391     Record rec;
 392     off_t recordOffset = 0;
 393     struct recExtractCtrl extractCtrl;
 394
 395     /* announce database */
 396     if (zebraExplain_curDatabase (zh->reg->zei, zh->basenames[0]))
 397     {
 398         if (zebraExplain_newDatabase (zh->reg->zei, zh->basenames[0],
 399                                       zh->m_explain_database))
 400             return 0;
 401     }
 402
 403     if (fi->fd != -1)
 404     {
 405         /* we are going to read from a file, so prepare the extraction */
 406         zebra_rec_keys_reset(zh->reg->keys);
 407
 408 #if NATTR
 409         zebra_rec_keys_reset(zh->reg->sortKeys);
 410 #else
 411         zh->reg->sortKeys.buf_used = 0;
 412 #endif
 413         recordOffset = fi->file_moffset;
 414         extractCtrl.handle = zh;
 415         extractCtrl.offset = fi->file_moffset;
 416         extractCtrl.readf = file_read;
 417         extractCtrl.seekf = file_seek;
 418         extractCtrl.tellf = file_tell;
 419         extractCtrl.endf = file_end;
 420         extractCtrl.fh = fi;
 421         extractCtrl.init = extract_init;
 422         extractCtrl.tokenAdd = extract_token_add;
 423         extractCtrl.schemaAdd = extract_schema_add;
 424         extractCtrl.dh = zh->reg->dh;
 425         extractCtrl.match_criteria[0] = '\0';
 426         extractCtrl.staticrank = 0;
 427
 428         extractCtrl.first_record = fi->file_offset ? 0 : 1;
 429
 430         extract_set_store_data_prepare(&extractCtrl);
 431
 432         init_extractCtrl(zh, &extractCtrl);
 433
 434         if (!zh->m_flag_rw)
 435             printf ("File: %s " PRINTF_OFF_T "\n", fname, recordOffset);
 436         if (zh->m_flag_rw)
 437         {
 438             char msg[512];
 439             sprintf (msg, "%s:" PRINTF_OFF_T , fname, recordOffset);
 440             yaz_log_init_prefix2 (msg);
 441         }
 442
 443         r = (*recType->extract)(recTypeClientData, &extractCtrl);
 444
 445         yaz_log_init_prefix2 (0);
 446         if (r == RECCTRL_EXTRACT_EOF)
 447             return 0;
 448         else if (r == RECCTRL_EXTRACT_ERROR_GENERIC)
 449         {
 450             /* error occured during extraction ... */
 451             if (zh->m_flag_rw &&
 452                 zh->records_processed < zh->m_file_verbose_limit)
 453             {
 454                 yaz_log (YLOG_WARN, "fail %s %s " PRINTF_OFF_T, zh->m_record_type,
 455                       fname, recordOffset);
 456             }
 457             return 0;
 458         }
 459         else if (r == RECCTRL_EXTRACT_ERROR_NO_SUCH_FILTER)
 460         {
 461             /* error occured during extraction ... */
 462             if (zh->m_flag_rw &&
 463                 zh->records_processed < zh->m_file_verbose_limit)
 464             {
 465                 yaz_log (YLOG_WARN, "no filter for %s %s "
 466                       PRINTF_OFF_T, zh->m_record_type,
 467                       fname, recordOffset);
 468             }
 469             return 0;
 470         }
 471         if (extractCtrl.match_criteria[0])
 472             matchStr = extractCtrl.match_criteria;
 473     }
 474
 475     /* perform match if sysno not known and if match criteria is specified */
 476     if (!sysno)
 477     {
 478         sysnotmp = 0;
 479         sysno = &sysnotmp;
 480
 481         if (matchStr == 0 && zh->m_record_id && *zh->m_record_id)
 482         {
 483             matchStr = fileMatchStr (zh, zh->reg->keys, fname,
 484                                      zh->m_record_id);
 485             if (!matchStr)
 486             {
 487                 yaz_log(YLOG_WARN, "Bad match criteria");
 488                 return 0;
 489             }
 490         }
 491         if (matchStr)
 492         {
 493             char *rinfo = dict_lookup (zh->reg->matchDict, matchStr);
 494             if (rinfo)
 495             {
 496                 assert(*rinfo == sizeof(*sysno));
 497                 memcpy (sysno, rinfo+1, sizeof(*sysno));
 498             }
 499         }
 500     }
 501     if (! *sysno && zebra_rec_keys_empty(zh->reg->keys) )
 502     {
 503          /* the extraction process returned no information - the record
 504             is probably empty - unless flagShowRecords is in use */
 505          if (!zh->m_flag_rw)
 506              return 1;
 507
 508          if (zh->records_processed < zh->m_file_verbose_limit)
 509              yaz_log (YLOG_WARN, "empty %s %s " PRINTF_OFF_T, zh->m_record_type,
 510             fname, recordOffset);
 511          return 1;
 512     }
 513
 514     if (! *sysno)
 515     {
 516         /* new record */
 517         if (deleteFlag)
 518         {
 519             yaz_log (YLOG_LOG, "delete %s %s " PRINTF_OFF_T, zh->m_record_type,
 520                   fname, recordOffset);
 521             yaz_log (YLOG_WARN, "cannot delete record above (seems new)");
 522             return 1;
 523         }
 524         if (zh->records_processed < zh->m_file_verbose_limit)
 525             yaz_log (YLOG_LOG, "add %s %s " PRINTF_OFF_T, zh->m_record_type,
 526                   fname, recordOffset);
 527         rec = rec_new (zh->reg->records);
 528
 529         *sysno = rec->sysno;
 530
 531         recordAttr = rec_init_attr (zh->reg->zei, rec);
 532         recordAttr->staticrank = extractCtrl.staticrank;
 533
 534         if (matchStr)
 535         {
 536             dict_insert (zh->reg->matchDict, matchStr, sizeof(*sysno), sysno);
 537         }
 538         extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
 539         extract_flushRecordKeys (zh, *sysno, 1, zh->reg->keys,
 540                                  recordAttr->staticrank);
 541         zh->records_inserted++;
 542     }
 543     else
 544     {
 545         /* record already exists */
 546         zebra_rec_keys_t delkeys = zebra_rec_keys_open();
 547
 548 #if NATTR
 549         zebra_rec_keys_t sortKeys = zebra_rec_keys_open();
 550 #else
 551         struct sortKeys sortKeys;
 552 #endif
 553
 554         rec = rec_get (zh->reg->records, *sysno);
 555         assert (rec);
 556
 557         recordAttr = rec_init_attr (zh->reg->zei, rec);
 558
 559         zebra_rec_keys_set_buf(delkeys,
 560                                rec->info[recInfo_delKeys],
 561                                rec->size[recInfo_delKeys],
 562                                0);
 563
 564 #if NATTR
 565         zebra_rec_keys_set_buf(sortKeys,
 566                                rec->info[recInfo_sortKeys],
 567                                rec->size[recInfo_sortKeys],
 568                                0);
 569         extract_flushSortKeys (zh, *sysno, 0, sortKeys);
 570 #else
 571         sortKeys.buf_used = rec->size[recInfo_sortKeys];
 572         sortKeys.buf = rec->info[recInfo_sortKeys];
 573         extract_flushSortKeys (zh, *sysno, 0, &sortKeys);
 574 #endif
 575
 576         extract_flushRecordKeys (zh, *sysno, 0, delkeys,
 577                                  recordAttr->staticrank); /* old values */
 578         if (deleteFlag)
 579         {
 580             /* record going to be deleted */
 581             if (zebra_rec_keys_empty(delkeys))
 582             {
 583                 yaz_log (YLOG_LOG, "delete %s %s " PRINTF_OFF_T,
 584                          zh->m_record_type, fname, recordOffset);
 585                 yaz_log (YLOG_WARN, "cannot delete file above, storeKeys false");
 586             }
 587             else
 588             {
 589                 if (zh->records_processed < zh->m_file_verbose_limit)
 590                     yaz_log (YLOG_LOG, "delete %s %s " PRINTF_OFF_T,
 591                              zh->m_record_type, fname, recordOffset);
 592                 zh->records_deleted++;
 593                 if (matchStr)
 594                     dict_delete (zh->reg->matchDict, matchStr);
 595                 rec_del (zh->reg->records, &rec);
 596             }
 597             rec_rm (&rec);
 598             logRecord (zh);
 599             return 1;
 600         }
 601         else
 602         {
 603             /* record going to be updated */
 604             if (zebra_rec_keys_empty(delkeys))
 605             {
 606                 yaz_log (YLOG_LOG, "update %s %s " PRINTF_OFF_T,
 607                       zh->m_record_type, fname, recordOffset);
 608                 yaz_log (YLOG_WARN, "cannot update file above, storeKeys false");
 609             }
 610             else
 611             {
 612                 /* flush new keys for sort&search etc */
 613                 if (zh->records_processed < zh->m_file_verbose_limit)
 614                     yaz_log (YLOG_LOG, "update %s %s " PRINTF_OFF_T,
 615                         zh->m_record_type, fname, recordOffset);
 616                 recordAttr->staticrank = extractCtrl.staticrank;
 617                 extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
 618                 extract_flushRecordKeys (zh, *sysno, 1, zh->reg->keys,
 619                                          recordAttr->staticrank);
 620                 zh->records_updated++;
 621             }
 622         }
 623         zebra_rec_keys_close(delkeys);
 624 #if NATTR
 625         zebra_rec_keys_close(sortKeys);
 626 #endif
 627     }
 628     /* update file type */
 629     xfree (rec->info[recInfo_fileType]);
 630     rec->info[recInfo_fileType] =
 631         rec_strdup (zh->m_record_type, &rec->size[recInfo_fileType]);
 632
 633     /* update filename */
 634     xfree (rec->info[recInfo_filename]);
 635     rec->info[recInfo_filename] =
 636         rec_strdup (fname, &rec->size[recInfo_filename]);
 637
 638     /* update delete keys */
 639     xfree (rec->info[recInfo_delKeys]);
 640     if (!zebra_rec_keys_empty(zh->reg->keys) && zh->m_store_keys == 1)
 641     {
 642         zebra_rec_keys_get_buf(zh->reg->keys,
 643                                &rec->info[recInfo_delKeys],
 644                                &rec->size[recInfo_delKeys]);
 645     }
 646     else
 647     {
 648         rec->info[recInfo_delKeys] = NULL;
 649         rec->size[recInfo_delKeys] = 0;
 650     }
 651
 652     /* update sort keys */
 653     xfree (rec->info[recInfo_sortKeys]);
 654
 655     rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
 656     rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
 657     zh->reg->sortKeys.buf = NULL;
 658     zh->reg->sortKeys.buf_max = 0;
 659
 660     /* save file size of original record */
 661     zebraExplain_recordBytesIncrement (zh->reg->zei,
 662                                        - recordAttr->recordSize);
 663     recordAttr->recordSize = fi->file_moffset - recordOffset;
 664     if (!recordAttr->recordSize)
 665         recordAttr->recordSize = fi->file_max - recordOffset;
 666     zebraExplain_recordBytesIncrement (zh->reg->zei,
 667                                        recordAttr->recordSize);
 668
 669     /* set run-number for this record */
 670     recordAttr->runNumber = zebraExplain_runNumberIncrement (zh->reg->zei,
 671                                                              0);
 672
 673     /* update store data */
 674     xfree (rec->info[recInfo_storeData]);
 675     if (zh->store_data_buf)
 676     {
 677         rec->size[recInfo_storeData] = zh->store_data_size;
 678         rec->info[recInfo_storeData] = zh->store_data_buf;
 679         zh->store_data_buf = 0;
 680     }
 681     else if (zh->m_store_data)
 682     {
 683         rec->size[recInfo_storeData] = recordAttr->recordSize;
 684         rec->info[recInfo_storeData] = (char *)
 685             xmalloc (recordAttr->recordSize);
 686         if (lseek (fi->fd, recordOffset, SEEK_SET) < 0)
 687         {
 688             yaz_log (YLOG_ERRNO|YLOG_FATAL, "seek to " PRINTF_OFF_T " in %s",
 689                   recordOffset, fname);
 690             exit (1);
 691         }
 692         if (read (fi->fd, rec->info[recInfo_storeData], recordAttr->recordSize)
 693             < recordAttr->recordSize)
 694         {
 695             yaz_log (YLOG_ERRNO|YLOG_FATAL, "read %d bytes of %s",
 696                   recordAttr->recordSize, fname);
 697             exit (1);
 698         }
 699     }
 700     else
 701     {
 702         rec->info[recInfo_storeData] = NULL;
 703         rec->size[recInfo_storeData] = 0;
 704     }
 705     /* update database name */
 706     xfree (rec->info[recInfo_databaseName]);
 707     rec->info[recInfo_databaseName] =
 708         rec_strdup (zh->basenames[0], &rec->size[recInfo_databaseName]);
 709
 710     /* update offset */
 711     recordAttr->recordOffset = recordOffset;
 712
 713     /* commit this record */
 714     rec_put (zh->reg->records, &rec);
 715     logRecord (zh);
 716     return 1;
 717 }
 718
 719 int fileExtract (ZebraHandle zh, SYSNO *sysno, const char *fname,
 720                  int deleteFlag)
 721 {
 722     int r, i, fd;
 723     char gprefix[128];
 724     char ext[128];
 725     char ext_res[128];
 726     struct file_read_info *fi;
 727     const char *original_record_type = 0;
 728     RecType recType;
 729     void *recTypeClientData;
 730
 731     if (!zh->m_group || !*zh->m_group)
 732         *gprefix = '\0';
 733     else
 734         sprintf (gprefix, "%s.", zh->m_group);
 735
 736     yaz_log (YLOG_DEBUG, "fileExtract %s", fname);
 737
 738     /* determine file extension */
 739     *ext = '\0';
 740     for (i = strlen(fname); --i >= 0; )
 741         if (fname[i] == '/')
 742             break;
 743         else if (fname[i] == '.')
 744         {
 745             strcpy (ext, fname+i+1);
 746             break;
 747         }
 748     /* determine file type - depending on extension */
 749     original_record_type = zh->m_record_type;
 750     if (!zh->m_record_type)
 751     {
 752         sprintf (ext_res, "%srecordType.%s", gprefix, ext);
 753         zh->m_record_type = res_get (zh->res, ext_res);
 754     }
 755     if (!zh->m_record_type)
 756     {
 757         if (zh->records_processed < zh->m_file_verbose_limit)
 758             yaz_log (YLOG_LOG, "? %s", fname);
 759         return 0;
 760     }
 761     /* determine match criteria */
 762     if (!zh->m_record_id)
 763     {
 764         sprintf (ext_res, "%srecordId.%s", gprefix, ext);
 765         zh->m_record_id = res_get (zh->res, ext_res);
 766     }
 767
 768     if (!(recType =
 769           recType_byName (zh->reg->recTypes, zh->res, zh->m_record_type,
 770                           &recTypeClientData)))
 771     {
 772         yaz_log(YLOG_WARN, "No such record type: %s", zh->m_record_type);
 773         return 0;
 774     }
 775
 776     switch(recType->version)
 777     {
 778     case 0:
 779         break;
 780     default:
 781         yaz_log(YLOG_WARN, "Bad filter version: %s", zh->m_record_type);
 782     }
 783     if (sysno && deleteFlag)
 784         fd = -1;
 785     else
 786     {
 787         char full_rep[1024];
 788
 789         if (zh->path_reg && !yaz_is_abspath (fname))
 790         {
 791             strcpy (full_rep, zh->path_reg);
 792             strcat (full_rep, "/");
 793             strcat (full_rep, fname);
 794         }
 795         else
 796             strcpy (full_rep, fname);
 797
 798
 799         if ((fd = open (full_rep, O_BINARY|O_RDONLY)) == -1)
 800         {
 801             yaz_log (YLOG_WARN|YLOG_ERRNO, "open %s", full_rep);
 802             zh->m_record_type = original_record_type;
 803             return 0;
 804         }
 805     }
 806     fi = file_read_start (fd);
 807     do
 808     {
 809         fi->file_moffset = fi->file_offset;
 810         fi->file_more = 0;  /* file_end not called (yet) */
 811         r = file_extract_record (zh, sysno, fname, deleteFlag, fi, 1,
 812                                  recType, recTypeClientData);
 813         if (fi->file_more)
 814         {   /* file_end has been called so reset offset .. */
 815             fi->file_offset = fi->file_moffset;
 816             lseek(fi->fd, fi->file_moffset, SEEK_SET);
 817         }
 818     }
 819     while (r && !sysno);
 820     file_read_stop (fi);
 821     if (fd != -1)
 822         close (fd);
 823     zh->m_record_type = original_record_type;
 824     return r;
 825 }
 826
 827 /*
 828   If sysno is provided, then it's used to identify the reocord.
 829   If not, and match_criteria is provided, then sysno is guessed
 830   If not, and a record is provided, then sysno is got from there
 831
 832  */
 833 ZEBRA_RES buffer_extract_record(ZebraHandle zh,
 834                                 const char *buf, size_t buf_size,
 835                                 int delete_flag,
 836                                 int test_mode,
 837                                 const char *recordType,
 838                                 SYSNO *sysno,
 839                                 const char *match_criteria,
 840                                 const char *fname,
 841                                 int force_update,
 842                                 int allow_update)
 843 {
 844     RecordAttr *recordAttr;
 845     struct recExtractCtrl extractCtrl;
 846     int r;
 847     const char *matchStr = 0;
 848     RecType recType = NULL;
 849     void *clientData;
 850     Record rec;
 851     long recordOffset = 0;
 852     struct zebra_fetch_control fc;
 853     const char *pr_fname = fname;  /* filename to print .. */
 854     int show_progress = zh->records_processed < zh->m_file_verbose_limit ? 1:0;
 855
 856     if (!pr_fname)
 857         pr_fname = "<no file>";  /* make it printable if file is omitted */
 858
 859     fc.fd = -1;
 860     fc.record_int_buf = buf;
 861     fc.record_int_len = buf_size;
 862     fc.record_int_pos = 0;
 863     fc.offset_end = 0;
 864     fc.record_offset = 0;
 865
 866     extractCtrl.offset = 0;
 867     extractCtrl.readf = zebra_record_int_read;
 868     extractCtrl.seekf = zebra_record_int_seek;
 869     extractCtrl.tellf = zebra_record_int_tell;
 870     extractCtrl.endf = zebra_record_int_end;
 871     extractCtrl.first_record = 1;
 872     extractCtrl.fh = &fc;
 873
 874     zebra_rec_keys_reset(zh->reg->keys);
 875
 876 #if NATTR
 877     zebra_rec_keys_reset(zh->reg->sortKeys);
 878 #else
 879     zh->reg->sortKeys.buf_used = 0;
 880 #endif
 881     if (zebraExplain_curDatabase (zh->reg->zei, zh->basenames[0]))
 882     {
 883         if (zebraExplain_newDatabase (zh->reg->zei, zh->basenames[0],
 884                                       zh->m_explain_database))
 885             return ZEBRA_FAIL;
 886     }
 887
 888     if (recordType && *recordType)
 889     {
 890         yaz_log (YLOG_DEBUG, "Record type explicitly specified: %s", recordType);
 891         recType = recType_byName (zh->reg->recTypes, zh->res, recordType,
 892                                   &clientData);
 893     }
 894     else
 895     {
 896         if (!(zh->m_record_type))
 897         {
 898             yaz_log (YLOG_WARN, "No such record type defined");
 899             return ZEBRA_FAIL;
 900         }
 901         yaz_log (YLOG_DEBUG, "Get record type from rgroup: %s",zh->m_record_type);
 902         recType = recType_byName (zh->reg->recTypes, zh->res,
 903                                   zh->m_record_type, &clientData);
 904         recordType = zh->m_record_type;
 905     }
 906
 907     if (!recType)
 908     {
 909         yaz_log (YLOG_WARN, "No such record type: %s", zh->m_record_type);
 910         return ZEBRA_FAIL;
 911     }
 912
 913     extractCtrl.init = extract_init;
 914     extractCtrl.tokenAdd = extract_token_add;
 915     extractCtrl.schemaAdd = extract_schema_add;
 916     extractCtrl.dh = zh->reg->dh;
 917     extractCtrl.handle = zh;
 918     extractCtrl.match_criteria[0] = '\0';
 919     extractCtrl.staticrank = 0;
 920
 921     init_extractCtrl(zh, &extractCtrl);
 922
 923     extract_set_store_data_prepare(&extractCtrl);
 924
 925     r = (*recType->extract)(clientData, &extractCtrl);
 926
 927     if (r == RECCTRL_EXTRACT_EOF)
 928         return ZEBRA_FAIL;
 929     else if (r == RECCTRL_EXTRACT_ERROR_GENERIC)
 930     {
 931         /* error occured during extraction ... */
 932         yaz_log (YLOG_WARN, "extract error: generic");
 933         return ZEBRA_FAIL;
 934     }
 935     else if (r == RECCTRL_EXTRACT_ERROR_NO_SUCH_FILTER)
 936     {
 937         /* error occured during extraction ... */
 938         yaz_log (YLOG_WARN, "extract error: no such filter");
 939         return ZEBRA_FAIL;
 940     }
 941     /* match criteria */
 942     matchStr = NULL;
 943
 944     if (extractCtrl.match_criteria[0])
 945         match_criteria = extractCtrl.match_criteria;
 946
 947     if (! *sysno) {
 948         char *rinfo;
 949         if (match_criteria && *match_criteria) {
 950             matchStr = match_criteria;
 951         } else {
 952             if (zh->m_record_id && *zh->m_record_id) {
 953                 matchStr = fileMatchStr (zh, zh->reg->keys, pr_fname,
 954                                          zh->m_record_id);
 955                 if (!matchStr)
 956                 {
 957                     yaz_log (YLOG_WARN, "Bad match criteria (recordID)");
 958                     return ZEBRA_FAIL;
 959                 }
 960             }
 961         }
 962         if (matchStr) {
 963             rinfo = dict_lookup (zh->reg->matchDict, matchStr);
 964             if (rinfo)
 965             {
 966                 assert(*rinfo == sizeof(*sysno));
 967                 memcpy (sysno, rinfo+1, sizeof(*sysno));
 968             }
 969         }
 970     }
 971     if (zebra_rec_keys_empty(zh->reg->keys))
 972     {
 973         /* the extraction process returned no information - the record
 974            is probably empty - unless flagShowRecords is in use */
 975         if (test_mode)
 976             return ZEBRA_OK;
 977     }
 978
 979     if (! *sysno)
 980     {
 981         /* new record */
 982         if (delete_flag)
 983         {
 984             if (show_progress)
 985                 yaz_log (YLOG_LOG, "delete %s %s %ld", recordType,
 986                          pr_fname, (long) recordOffset);
 987             yaz_log (YLOG_WARN, "cannot delete record above (seems new)");
 988             return ZEBRA_FAIL;
 989         }
 990         if (show_progress)
 991             yaz_log (YLOG_LOG, "add %s %s %ld", recordType, pr_fname,
 992                      (long) recordOffset);
 993         rec = rec_new (zh->reg->records);
 994
 995         *sysno = rec->sysno;
 996
 997         recordAttr = rec_init_attr (zh->reg->zei, rec);
 998         recordAttr->staticrank = extractCtrl.staticrank;
 999
1000         if (matchStr)
1001         {
1002             dict_insert (zh->reg->matchDict, matchStr,
1003                          sizeof(*sysno), sysno);
1004         }
1005         extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
1006
1007 #if 0
1008         print_rec_keys(zh, zh->reg->keys);
1009 #endif
1010         extract_flushRecordKeys (zh, *sysno, 1, zh->reg->keys,
1011                          recordAttr->staticrank);
1012         zh->records_inserted++;
1013     }
1014     else
1015     {
1016         /* record already exists */
1017         zebra_rec_keys_t delkeys = zebra_rec_keys_open();
1018 #if NATTR
1019         zebra_rec_keys_t sortKeys = zebra_rec_keys_open();
1020 #else
1021         struct sortKeys sortKeys;
1022 #endif
1023
1024         if (!allow_update)
1025         {
1026             if (show_progress)
1027                 yaz_log (YLOG_LOG, "skipped %s %s %ld",
1028                          recordType, pr_fname, (long) recordOffset);
1029             logRecord(zh);
1030             return ZEBRA_FAIL;
1031         }
1032
1033         rec = rec_get (zh->reg->records, *sysno);
1034         assert (rec);
1035
1036         recordAttr = rec_init_attr (zh->reg->zei, rec);
1037
1038         zebra_rec_keys_set_buf(delkeys,
1039                                rec->info[recInfo_delKeys],
1040                                rec->size[recInfo_delKeys],
1041                                0);
1042         sortKeys.buf_used = rec->size[recInfo_sortKeys];
1043         sortKeys.buf = rec->info[recInfo_sortKeys];
1044
1045 #if NATTR
1046         extract_flushSortKeys (zh, *sysno, 0, sortKeys);
1047 #else
1048         extract_flushSortKeys (zh, *sysno, 0, &sortKeys);
1049 #endif
1050         extract_flushRecordKeys (zh, *sysno, 0, delkeys,
1051                                  recordAttr->staticrank);
1052         if (delete_flag)
1053         {
1054             /* record going to be deleted */
1055             if (zebra_rec_keys_empty(delkeys))
1056             {
1057                 if (show_progress)
1058                 {
1059                     yaz_log (YLOG_LOG, "delete %s %s %ld", recordType,
1060                              pr_fname, (long) recordOffset);
1061                     yaz_log (YLOG_WARN, "cannot delete file above, "
1062                              "storeKeys false");
1063                 }
1064             }
1065             else
1066             {
1067                 if (show_progress)
1068                     yaz_log (YLOG_LOG, "delete %s %s %ld", recordType,
1069                              pr_fname, (long) recordOffset);
1070                 zh->records_deleted++;
1071                 if (matchStr)
1072                     dict_delete (zh->reg->matchDict, matchStr);
1073                 rec_del (zh->reg->records, &rec);
1074             }
1075             rec_rm (&rec);
1076             logRecord(zh);
1077             return ZEBRA_OK;
1078         }
1079         else
1080         {
1081             /* record going to be updated */
1082             if (zebra_rec_keys_empty(delkeys))
1083             {
1084                 if (show_progress)
1085                 {
1086                     yaz_log (YLOG_LOG, "update %s %s %ld", recordType,
1087                              pr_fname, (long) recordOffset);
1088                     yaz_log (YLOG_WARN, "cannot update file above, storeKeys false");
1089                 }
1090             }
1091             else
1092             {
1093                 if (show_progress)
1094                     yaz_log (YLOG_LOG, "update %s %s %ld", recordType,
1095                              pr_fname, (long) recordOffset);
1096                 recordAttr->staticrank = extractCtrl.staticrank;
1097                 extract_flushSortKeys (zh, *sysno, 1, &zh->reg->sortKeys);
1098                 extract_flushRecordKeys (zh, *sysno, 1, zh->reg->keys,
1099                                          recordAttr->staticrank);
1100                 zh->records_updated++;
1101             }
1102         }
1103         zebra_rec_keys_close(delkeys);
1104 #if NATTR
1105         zebra_rec_keys_close(sortKeys);
1106 #endif
1107     }
1108     /* update file type */
1109     xfree (rec->info[recInfo_fileType]);
1110     rec->info[recInfo_fileType] =
1111         rec_strdup (recordType, &rec->size[recInfo_fileType]);
1112
1113     /* update filename */
1114     xfree (rec->info[recInfo_filename]);
1115     rec->info[recInfo_filename] =
1116         rec_strdup (fname, &rec->size[recInfo_filename]);
1117
1118     /* update delete keys */
1119     xfree (rec->info[recInfo_delKeys]);
1120     if (!zebra_rec_keys_empty(zh->reg->keys) && zh->m_store_keys == 1)
1121     {
1122         zebra_rec_keys_get_buf(zh->reg->keys,
1123                                &rec->info[recInfo_delKeys],
1124                                &rec->size[recInfo_delKeys]);
1125     }
1126     else
1127     {
1128         rec->info[recInfo_delKeys] = NULL;
1129         rec->size[recInfo_delKeys] = 0;
1130     }
1131     /* update sort keys */
1132     xfree (rec->info[recInfo_sortKeys]);
1133
1134     rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
1135     rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
1136     zh->reg->sortKeys.buf = NULL;
1137     zh->reg->sortKeys.buf_max = 0;
1138
1139     /* save file size of original record */
1140     zebraExplain_recordBytesIncrement (zh->reg->zei,
1141                                        - recordAttr->recordSize);
1142 #if 0
1143     recordAttr->recordSize = fi->file_moffset - recordOffset;
1144     if (!recordAttr->recordSize)
1145         recordAttr->recordSize = fi->file_max - recordOffset;
1146 #else
1147     recordAttr->recordSize = buf_size;
1148 #endif
1149     zebraExplain_recordBytesIncrement (zh->reg->zei,
1150                                        recordAttr->recordSize);
1151
1152     /* set run-number for this record */
1153     recordAttr->runNumber =
1154         zebraExplain_runNumberIncrement (zh->reg->zei, 0);
1155
1156     /* update store data */
1157     xfree (rec->info[recInfo_storeData]);
1158
1159     /* update store data */
1160     if (zh->store_data_buf)
1161     {
1162         rec->size[recInfo_storeData] = zh->store_data_size;
1163         rec->info[recInfo_storeData] = zh->store_data_buf;
1164         zh->store_data_buf = 0;
1165     }
1166     else if (zh->m_store_data)
1167     {
1168         rec->size[recInfo_storeData] = recordAttr->recordSize;
1169         rec->info[recInfo_storeData] = (char *)
1170             xmalloc (recordAttr->recordSize);
1171         memcpy (rec->info[recInfo_storeData], buf, recordAttr->recordSize);
1172     }
1173     else
1174     {
1175         rec->info[recInfo_storeData] = NULL;
1176         rec->size[recInfo_storeData] = 0;
1177     }
1178     /* update database name */
1179     xfree (rec->info[recInfo_databaseName]);
1180     rec->info[recInfo_databaseName] =
1181         rec_strdup (zh->basenames[0], &rec->size[recInfo_databaseName]);
1182
1183     /* update offset */
1184     recordAttr->recordOffset = recordOffset;
1185
1186     /* commit this record */
1187     rec_put (zh->reg->records, &rec);
1188     logRecord(zh);
1189     return ZEBRA_OK;
1190 }
1191
1192 int explain_extract (void *handle, Record rec, data1_node *n)
1193 {
1194     ZebraHandle zh = (ZebraHandle) handle;
1195     struct recExtractCtrl extractCtrl;
1196
1197     if (zebraExplain_curDatabase (zh->reg->zei,
1198                                   rec->info[recInfo_databaseName]))
1199     {
1200         abort();
1201         if (zebraExplain_newDatabase (zh->reg->zei,
1202                                       rec->info[recInfo_databaseName], 0))
1203             abort ();
1204     }
1205
1206     zebra_rec_keys_reset(zh->reg->keys);
1207
1208 #if NATTR
1209     zebra_rec_keys_reset(zh->reg->sortKeys);
1210 #else
1211     zh->reg->sortKeys.buf_used = 0;
1212 #endif
1213     extractCtrl.init = extract_init;
1214     extractCtrl.tokenAdd = extract_token_add;
1215     extractCtrl.schemaAdd = extract_schema_add;
1216     extractCtrl.dh = zh->reg->dh;
1217
1218     init_extractCtrl(zh, &extractCtrl);
1219
1220     extractCtrl.flagShowRecords = 0;
1221     extractCtrl.match_criteria[0] = '\0';
1222     extractCtrl.staticrank = 0;
1223     extractCtrl.handle = handle;
1224     extractCtrl.first_record = 1;
1225
1226     extract_set_store_data_prepare(&extractCtrl);
1227
1228     if (n)
1229         grs_extract_tree(&extractCtrl, n);
1230
1231     if (rec->size[recInfo_delKeys])
1232     {
1233         zebra_rec_keys_t delkeys = zebra_rec_keys_open();
1234
1235 #if NATTR
1236         zebra_rec_keys_t sortkeys = zzebra_rec_keys_open();
1237 #else
1238         struct sortKeys sortkeys;
1239 #endif
1240
1241         zebra_rec_keys_set_buf(delkeys, rec->info[recInfo_delKeys],
1242                                rec->size[recInfo_delKeys],
1243                                0);
1244         extract_flushRecordKeys (zh, rec->sysno, 0, delkeys, 0);
1245         zebra_rec_keys_close(delkeys);
1246 #if NATTR
1247         zebra_rec_keys_set_buf(sortkeys, rec->info[recInfo_sortKeys],
1248                                rec->size[recInfo_sortKeys],
1249                                0);
1250
1251         extract_flushSortKeys (zh, rec->sysno, 0, sortkeys);
1252         zebra_rec_keys_close(sortkeys);
1253 #else
1254         sortkeys.buf_used = rec->size[recInfo_sortKeys];
1255         sortkeys.buf = rec->info[recInfo_sortKeys];
1256         extract_flushSortKeys (zh, rec->sysno, 0, &sortkeys);
1257 #endif
1258     }
1259     extract_flushRecordKeys (zh, rec->sysno, 1, zh->reg->keys, 0);
1260 #if NATTR
1261     extract_flushSortKeys (zh, rec->sysno, 1, zh->reg->sortKeys);
1262 #else
1263     extract_flushSortKeys (zh, rec->sysno, 1, &zh->reg->sortKeys);
1264 #endif
1265
1266     xfree (rec->info[recInfo_delKeys]);
1267     zebra_rec_keys_get_buf(zh->reg->keys,
1268                            &rec->info[recInfo_delKeys],
1269                            &rec->size[recInfo_delKeys]);
1270
1271     xfree (rec->info[recInfo_sortKeys]);
1272     rec->size[recInfo_sortKeys] = zh->reg->sortKeys.buf_used;
1273     rec->info[recInfo_sortKeys] = zh->reg->sortKeys.buf;
1274     zh->reg->sortKeys.buf = NULL;
1275     zh->reg->sortKeys.buf_max = 0;
1276
1277     return 0;
1278 }
1279
1280 void extract_flushRecordKeys (ZebraHandle zh, SYSNO sysno,
1281                               int cmd,
1282                               zebra_rec_keys_t reckeys,
1283                               zint staticrank)
1284 {
1285     ZebraExplainInfo zei = zh->reg->zei;
1286
1287     if (!zh->reg->key_buf)
1288     {
1289         int mem= 1024*1024* atoi( res_get_def( zh->res, "memmax", "8"));
1290         if (mem <= 0)
1291         {
1292             yaz_log(YLOG_WARN, "Invalid memory setting, using default 8 MB");
1293             mem= 1024*1024*8;
1294         }
1295         /* FIXME: That "8" should be in a default settings include */
1296         /* not hard-coded here! -H */
1297         zh->reg->key_buf = (char**) xmalloc (mem);
1298         zh->reg->ptr_top = mem/sizeof(char*);
1299         zh->reg->ptr_i = 0;
1300         zh->reg->key_buf_used = 0;
1301         zh->reg->key_file_no = 0;
1302     }
1303     zebraExplain_recordCountIncrement (zei, cmd ? 1 : -1);
1304
1305     if (zebra_rec_keys_rewind(reckeys))
1306     {
1307         size_t slen;
1308         const char *str;
1309         struct it_key key_in;
1310         while(zebra_rec_keys_read(reckeys, &str, &slen, &key_in))
1311         {
1312             int ch = 0;
1313             struct it_key key_out;
1314             zint *keyp = key_out.mem;
1315
1316             assert(key_in.len == 4);
1317
1318             /* check for buffer overflow */
1319             if (zh->reg->key_buf_used + 1024 >
1320                 (zh->reg->ptr_top -zh->reg->ptr_i)*sizeof(char*))
1321                 extract_flushWriteKeys (zh, 0);
1322
1323             ++(zh->reg->ptr_i);
1324             assert(zh->reg->ptr_i > 0);
1325             (zh->reg->key_buf)[zh->reg->ptr_top - zh->reg->ptr_i] =
1326                 (char*)zh->reg->key_buf + zh->reg->key_buf_used;
1327
1328             /* encode the ordinal value (field/use/attribute) .. */
1329             ch = (int) key_in.mem[0];
1330             zh->reg->key_buf_used +=
1331                 key_SU_encode(ch, (char*)zh->reg->key_buf +
1332                               zh->reg->key_buf_used);
1333
1334             /* copy the 0-terminated stuff from str to output */
1335             memcpy((char*)zh->reg->key_buf + zh->reg->key_buf_used, str, slen);
1336             zh->reg->key_buf_used += slen;
1337             ((char*)zh->reg->key_buf)[(zh->reg->key_buf_used)++] = '\0';
1338
1339             /* the delete/insert indicator */
1340             ((char*)zh->reg->key_buf)[(zh->reg->key_buf_used)++] = cmd;
1341
1342             if (zh->m_staticrank) /* rank config enabled ? */
1343             {
1344                 *keyp++ = staticrank;
1345                 key_out.len = 4;
1346             }
1347             else
1348                 key_out.len = 3;
1349
1350             if (key_in.mem[1]) /* filter specified record ID */
1351                 *keyp++ = key_in.mem[1];
1352             else
1353                 *keyp++ = sysno;
1354             *keyp++ = key_in.mem[2];  /* section_id */
1355             *keyp++ = key_in.mem[3];  /* sequence .. */
1356
1357             memcpy((char*)zh->reg->key_buf + zh->reg->key_buf_used,
1358                    &key_out, sizeof(key_out));
1359             (zh->reg->key_buf_used) += sizeof(key_out);
1360         }
1361     }
1362 }
1363
1364 void extract_flushWriteKeys (ZebraHandle zh, int final)
1365         /* optimizing: if final=1, and no files written yet */
1366         /* push the keys directly to merge, sidestepping the */
1367         /* temp file altogether. Speeds small updates */
1368 {
1369     FILE *outf;
1370     char out_fname[200];
1371     char *prevcp, *cp;
1372     struct encode_info encode_info;
1373     int ptr_i = zh->reg->ptr_i;
1374     int temp_policy;
1375 #if SORT_EXTRA
1376     int i;
1377 #endif
1378     if (!zh->reg->key_buf || ptr_i <= 0)
1379     {
1380         yaz_log (YLOG_DEBUG, "  nothing to flush section=%d buf=%p i=%d",
1381                zh->reg->key_file_no, zh->reg->key_buf, ptr_i);
1382         yaz_log (YLOG_DEBUG, "  buf=%p ",
1383                zh->reg->key_buf);
1384         yaz_log (YLOG_DEBUG, "  ptr=%d ",zh->reg->ptr_i);
1385         yaz_log (YLOG_DEBUG, "  reg=%p ",zh->reg);
1386
1387         return;
1388     }
1389
1390     (zh->reg->key_file_no)++;
1391     yaz_log (YLOG_LOG, "sorting section %d", (zh->reg->key_file_no));
1392     yaz_log (YLOG_DEBUG, "  sort_buff at %p n=%d",
1393                     zh->reg->key_buf + zh->reg->ptr_top - ptr_i,ptr_i);
1394 #if !SORT_EXTRA
1395     qsort (zh->reg->key_buf + zh->reg->ptr_top - ptr_i, ptr_i,
1396                sizeof(char*), key_qsort_compare);
1397
1398     /* zebra.cfg: tempfiles:
1399        Y: always use temp files (old way)
1400        A: use temp files, if more than one (auto)
1401           = if this is both the last and the first
1402        N: never bother with temp files (new) */
1403
1404     temp_policy=toupper(res_get_def(zh->res,"tempfiles","auto")[0]);
1405     if (temp_policy != 'Y' && temp_policy != 'N' && temp_policy != 'A') {
1406         yaz_log (YLOG_WARN, "Illegal tempfiles setting '%c'. using 'Auto' ",
1407                         temp_policy);
1408         temp_policy='A';
1409     }
1410
1411     if (   ( temp_policy =='N' )   ||     /* always from memory */
1412          ( ( temp_policy =='A' ) &&       /* automatic */
1413              (zh->reg->key_file_no == 1) &&  /* this is first time */
1414              (final) ) )                     /* and last (=only) time */
1415     { /* go directly from memory */
1416         zh->reg->key_file_no =0; /* signal not to read files */
1417         zebra_index_merge(zh);
1418         zh->reg->ptr_i = 0;
1419         zh->reg->key_buf_used = 0;
1420         return;
1421     }
1422
1423     /* Not doing directly from memory, write into a temp file */
1424     extract_get_fname_tmp (zh, out_fname, zh->reg->key_file_no);
1425
1426     if (!(outf = fopen (out_fname, "wb")))
1427     {
1428         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fopen %s", out_fname);
1429         exit (1);
1430     }
1431     yaz_log (YLOG_LOG, "writing section %d", zh->reg->key_file_no);
1432     prevcp = cp = (zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
1433
1434     encode_key_init (&encode_info);
1435     encode_key_write (cp, &encode_info, outf);
1436
1437     while (--ptr_i > 0)
1438     {
1439         cp = (zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
1440         if (strcmp (cp, prevcp))
1441         {
1442             encode_key_flush ( &encode_info, outf);
1443             encode_key_init (&encode_info);
1444             encode_key_write (cp, &encode_info, outf);
1445             prevcp = cp;
1446         }
1447         else
1448             encode_key_write (cp + strlen(cp), &encode_info, outf);
1449     }
1450     encode_key_flush ( &encode_info, outf);
1451 #else
1452     qsort (key_buf + ptr_top-ptr_i, ptr_i, sizeof(char*), key_x_compare);
1453     extract_get_fname_tmp (out_fname, key_file_no);
1454
1455     if (!(outf = fopen (out_fname, "wb")))
1456     {
1457         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fopen %s", out_fname);
1458         exit (1);
1459     }
1460     yaz_log (YLOG_LOG, "writing section %d", key_file_no);
1461     i = ptr_i;
1462     prevcp =  key_buf[ptr_top-i];
1463     while (1)
1464         if (!--i || strcmp (prevcp, key_buf[ptr_top-i]))
1465         {
1466             key_y_len = strlen(prevcp)+1;
1467 #if 0
1468             yaz_log (YLOG_LOG, "key_y_len: %2d %02x %02x %s",
1469                       key_y_len, prevcp[0], prevcp[1], 2+prevcp);
1470 #endif
1471             qsort (key_buf + ptr_top-ptr_i, ptr_i - i,
1472                                    sizeof(char*), key_y_compare);
1473             cp = key_buf[ptr_top-ptr_i];
1474             --key_y_len;
1475             encode_key_init (&encode_info);
1476             encode_key_write (cp, &encode_info, outf);
1477             while (--ptr_i > i)
1478             {
1479                 cp = key_buf[ptr_top-ptr_i];
1480                 encode_key_write (cp+key_y_len, &encode_info, outf);
1481             }
1482             encode_key_flush ( &encode_info, outf);
1483             if (!i)
1484                 break;
1485             prevcp = key_buf[ptr_top-ptr_i];
1486         }
1487 #endif
1488     if (fclose (outf))
1489     {
1490         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fclose %s", out_fname);
1491         exit (1);
1492     }
1493     yaz_log (YLOG_LOG, "finished section %d", zh->reg->key_file_no);
1494     zh->reg->ptr_i = 0;
1495     zh->reg->key_buf_used = 0;
1496 }
1497
1498 void extract_add_it_key (ZebraHandle zh,
1499                          zebra_rec_keys_t *keys,
1500                          int reg_type,
1501                          const char *str, int slen, struct it_key *key)
1502 {
1503     zebra_rec_keys_write(*keys, reg_type, str, slen, key);
1504 }
1505
1506 ZEBRA_RES zebra_snippets_rec_keys(ZebraHandle zh,
1507                                   zebra_rec_keys_t reckeys,
1508                                   zebra_snippets *snippets)
1509 {
1510     NMEM nmem = nmem_create();
1511     if (zebra_rec_keys_rewind(reckeys))
1512     {
1513         const char *str;
1514         size_t slen;
1515         struct it_key key;
1516         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
1517         {
1518             char dst_buf[IT_MAX_WORD];
1519             char *dst_term = dst_buf;
1520             int ord, seqno;
1521             int index_type;
1522             assert(key.len <= 4 && key.len > 2);
1523             seqno = (int) key.mem[key.len-1];
1524             ord = key.mem[0];
1525
1526             zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type,
1527                                     0/* db */, 0/* set */, 0/* use */);
1528             assert(index_type);
1529             zebra_term_untrans_iconv(zh, nmem, index_type,
1530                                      &dst_term, str);
1531             zebra_snippets_append(snippets, seqno, ord, dst_term);
1532             nmem_reset(nmem);
1533         }
1534     }
1535     nmem_destroy(nmem);
1536     return ZEBRA_OK;
1537 }
1538
1539 void print_rec_keys(ZebraHandle zh, zebra_rec_keys_t reckeys)
1540 {
1541     yaz_log(YLOG_LOG, "print_rec_keys");
1542     if (zebra_rec_keys_rewind(reckeys))
1543     {
1544         const char *str;
1545         size_t slen;
1546         struct it_key key;
1547         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
1548         {
1549             char dst_buf[IT_MAX_WORD];
1550             int seqno;
1551             int index_type;
1552             const char *db = 0;
1553             assert(key.len <= 4 && key.len > 2);
1554
1555             zebraExplain_lookup_ord(zh->reg->zei,
1556                                     key.mem[0], &index_type, &db, 0, 0);
1557
1558             seqno = (int) key.mem[key.len-1];
1559
1560             zebra_term_untrans(zh, index_type, dst_buf, str);
1561
1562             yaz_log(YLOG_LOG, "ord=" ZINT_FORMAT " seqno=%d term=%s",
1563                     key.mem[0], seqno, dst_buf);
1564         }
1565     }
1566 }
1567
1568 void extract_add_index_string (RecWord *p, const char *str, int length)
1569 {
1570     struct it_key key;
1571
1572     ZebraHandle zh = p->extractCtrl->handle;
1573     ZebraExplainInfo zei = zh->reg->zei;
1574     int ch;
1575
1576     if (p->index_name)
1577     {
1578         ch = zebraExplain_lookup_attr_str(zei, p->index_type, p->index_name);
1579         if (ch < 0)
1580             ch = zebraExplain_add_attr_str(zei, p->index_type, p->index_name);
1581     }
1582     else
1583     {
1584 #if NATTR
1585         return;
1586 #else
1587         ch = zebraExplain_lookup_attr_su(zei, p->index_type,
1588                                          p->attrSet, p->attrUse);
1589         if (ch < 0)
1590             ch = zebraExplain_add_attr_su(zei, p->index_type,
1591                                           p->attrSet, p->attrUse);
1592 #endif
1593     }
1594     key.len = 4;
1595     key.mem[0] = ch;
1596     key.mem[1] = p->record_id;
1597     key.mem[2] = p->section_id;
1598     key.mem[3] = p->seqno;
1599
1600 #if 0
1601     /* just for debugging .. */
1602     yaz_log(YLOG_LOG, "add: set=%d use=%d "
1603             "record_id=%lld section_id=%lld seqno=%lld",
1604             p->attrSet, p->attrUse, p->record_id, p->section_id, p->seqno);
1605 #endif
1606
1607     extract_add_it_key(p->extractCtrl->handle,
1608                        &zh->reg->keys,
1609                        p->index_type, str,
1610                        length, &key);
1611 }
1612
1613 #if NATTR
1614 static void extract_add_sort_string (RecWord *p, const char *str, int length)
1615 {
1616     struct it_key key;
1617
1618     ZebraHandle zh = p->extractCtrl->handle;
1619     ZebraExplainInfo zei = zh->reg->zei;
1620     int ch;
1621
1622     if (p->index_name)
1623     {
1624         ch = zebraExplain_lookup_attr_str(zei, p->index_type, p->index_name);
1625         if (ch < 0)
1626             ch = zebraExplain_add_attr_str(zei, p->index_type, p->index_name);
1627     }
1628     else
1629     {
1630         return;
1631     }
1632     key.len = 4;
1633     key.mem[0] = ch;
1634     key.mem[1] = p->record_id;
1635     key.mem[2] = p->section_id;
1636     key.mem[3] = p->seqno;
1637
1638     extract_add_it_key(p->extractCtrl->handle,
1639                        &zh->reg->sortKeys,
1640                        p->index_type, str,
1641                        length, &key);
1642 }
1643 #else
1644 static void extract_add_sort_string (RecWord *p, const char *str, int length)
1645 {
1646     ZebraHandle zh = p->extractCtrl->handle;
1647     struct sortKeys *sk = &zh->reg->sortKeys;
1648     int off = 0;
1649
1650     while (off < sk->buf_used)
1651     {
1652         int set, use, slen;
1653
1654         off += key_SU_decode(&set, (unsigned char *) sk->buf + off);
1655         off += key_SU_decode(&use, (unsigned char *) sk->buf + off);
1656         off += key_SU_decode(&slen, (unsigned char *) sk->buf + off);
1657         off += slen;
1658         if (p->attrSet == set && p->attrUse == use)
1659             return;
1660     }
1661     assert (off == sk->buf_used);
1662
1663     if (sk->buf_used + IT_MAX_WORD > sk->buf_max)
1664     {
1665         char *b;
1666
1667         b = (char *) xmalloc (sk->buf_max += 128000);
1668         if (sk->buf_used > 0)
1669             memcpy (b, sk->buf, sk->buf_used);
1670         xfree (sk->buf);
1671         sk->buf = b;
1672     }
1673     off += key_SU_encode(p->attrSet, sk->buf + off);
1674     off += key_SU_encode(p->attrUse, sk->buf + off);
1675     off += key_SU_encode(length, sk->buf + off);
1676     memcpy (sk->buf + off, str, length);
1677     sk->buf_used = off + length;
1678 }
1679 #endif
1680
1681 void extract_add_string (RecWord *p, const char *string, int length)
1682 {
1683     assert (length > 0);
1684     if (zebra_maps_is_sort (p->zebra_maps, p->index_type))
1685         extract_add_sort_string (p, string, length);
1686     else
1687         extract_add_index_string (p, string, length);
1688 }
1689
1690 static void extract_add_incomplete_field (RecWord *p)
1691 {
1692     const char *b = p->term_buf;
1693     int remain = p->term_len;
1694     const char **map = 0;
1695
1696     yaz_log(YLOG_DEBUG, "Incomplete field, w='%.*s'", p->term_len, p->term_buf);
1697
1698     if (remain > 0)
1699         map = zebra_maps_input(p->zebra_maps, p->index_type, &b, remain, 0);
1700
1701     while (map)
1702     {
1703         char buf[IT_MAX_WORD+1];
1704         int i, remain;
1705
1706         /* Skip spaces */
1707         while (map && *map && **map == *CHR_SPACE)
1708         {
1709             remain = p->term_len - (b - p->term_buf);
1710             if (remain > 0)
1711                 map = zebra_maps_input(p->zebra_maps, p->index_type, &b,
1712                                        remain, 0);
1713             else
1714                 map = 0;
1715         }
1716         if (!map)
1717             break;
1718         i = 0;
1719         while (map && *map && **map != *CHR_SPACE)
1720         {
1721             const char *cp = *map;
1722
1723             while (i < IT_MAX_WORD && *cp)
1724                 buf[i++] = *(cp++);
1725             remain = p->term_len - (b - p->term_buf);
1726             if (remain > 0)
1727                 map = zebra_maps_input(p->zebra_maps, p->index_type, &b, remain, 0);
1728             else
1729                 map = 0;
1730         }
1731         if (!i)
1732             return;
1733         extract_add_string (p, buf, i);
1734         p->seqno++;
1735     }
1736 }
1737
1738 static void extract_add_complete_field (RecWord *p)
1739 {
1740     const char *b = p->term_buf;
1741     char buf[IT_MAX_WORD+1];
1742     const char **map = 0;
1743     int i = 0, remain = p->term_len;
1744
1745     yaz_log(YLOG_DEBUG, "Complete field, w='%.*s'",
1746             p->term_len, p->term_buf);
1747
1748     if (remain > 0)
1749         map = zebra_maps_input (p->zebra_maps, p->index_type, &b, remain, 1);
1750
1751     while (remain > 0 && i < IT_MAX_WORD)
1752     {
1753         while (map && *map && **map == *CHR_SPACE)
1754         {
1755             remain = p->term_len - (b - p->term_buf);
1756
1757             if (remain > 0)
1758             {
1759                 int first = i ? 0 : 1;  /* first position */
1760                 map = zebra_maps_input(p->zebra_maps, p->index_type, &b, remain, first);
1761             }
1762             else
1763                 map = 0;
1764         }
1765         if (!map)
1766             break;
1767
1768         if (i && i < IT_MAX_WORD)
1769             buf[i++] = *CHR_SPACE;
1770         while (map && *map && **map != *CHR_SPACE)
1771         {
1772             const char *cp = *map;
1773
1774             if (**map == *CHR_CUT)
1775             {
1776                 i = 0;
1777             }
1778             else
1779             {
1780                 if (i >= IT_MAX_WORD)
1781                     break;
1782                 yaz_log(YLOG_DEBUG, "Adding string to index '%d'", **map);
1783                 while (i < IT_MAX_WORD && *cp)
1784                     buf[i++] = *(cp++);
1785             }
1786             remain = p->term_len  - (b - p->term_buf);
1787             if (remain > 0)
1788             {
1789                 map = zebra_maps_input (p->zebra_maps, p->index_type, &b,
1790                                         remain, 0);
1791             }
1792             else
1793                 map = 0;
1794         }
1795     }
1796     if (!i)
1797         return;
1798     extract_add_string (p, buf, i);
1799 }
1800
1801 void extract_token_add (RecWord *p)
1802 {
1803     WRBUF wrbuf;
1804 #if 0
1805     yaz_log (YLOG_LOG, "token_add "
1806              "reg_type=%c attrSet=%d attrUse=%d seqno=%d s=%.*s",
1807              p->reg_type, p->attrSet, p->attrUse, p->seqno, p->length,
1808              p->string);
1809 #endif
1810     if ((wrbuf = zebra_replace(p->zebra_maps, p->index_type, 0,
1811                                p->term_buf, p->term_len)))
1812     {
1813         p->term_buf = wrbuf_buf(wrbuf);
1814         p->term_len = wrbuf_len(wrbuf);
1815     }
1816     if (zebra_maps_is_complete (p->zebra_maps, p->index_type))
1817         extract_add_complete_field (p);
1818     else
1819         extract_add_incomplete_field(p);
1820 }
1821
1822 static void extract_set_store_data_cb(struct recExtractCtrl *p,
1823                                       void *buf, size_t sz)
1824 {
1825     ZebraHandle zh = (ZebraHandle) p->handle;
1826
1827     xfree(zh->store_data_buf);
1828     zh->store_data_buf = 0;
1829     zh->store_data_size = 0;
1830     if (buf && sz)
1831     {
1832         zh->store_data_buf = xmalloc(sz);
1833         zh->store_data_size = sz;
1834         memcpy(zh->store_data_buf, buf, sz);
1835     }
1836 }
1837
1838 static void extract_set_store_data_prepare(struct recExtractCtrl *p)
1839 {
1840     ZebraHandle zh = (ZebraHandle) p->handle;
1841     xfree(zh->store_data_buf);
1842     zh->store_data_buf = 0;
1843     zh->store_data_size = 0;
1844     p->setStoreData = extract_set_store_data_cb;
1845 }
1846
1847 void extract_schema_add (struct recExtractCtrl *p, Odr_oid *oid)
1848 {
1849     ZebraHandle zh = (ZebraHandle) p->handle;
1850     zebraExplain_addSchema (zh->reg->zei, oid);
1851 }
1852
1853 #if NATTR
1854 #error not done yet with zebra_rec_keys_t
1855 void extract_flushSortKeys (ZebraHandle zh, SYSNO sysno,
1856                             int cmd, struct recKeys *reckeys)
1857 {
1858     SortIdx sortIdx = zh->reg->sortIdx;
1859     void *decode_handle = iscz1_start();
1860     int off = 0;
1861     int ch = 0;
1862
1863     while (off < reckeys->buf_used)
1864     {
1865         const char *src = reckeys->buf + off;
1866         struct it_key key;
1867         char *dst = (char*) &key;
1868
1869         iscz1_decode(decode_handle, &dst, &src);
1870         assert(key.len == 4);
1871
1872         ch = (int) key.mem[0];  /* ordinal for field/use/attribute */
1873
1874         sortIdx_type(sortIdx, ch);
1875         if (cmd == 1)
1876             sortIdx_add(sortIdx, src, strlen(src));
1877         else
1878             sortIdx_add(sortIdx, "", 1);
1879
1880         src += strlen(src);
1881         src++;
1882
1883         off = src - reckeys->buf;
1884     }
1885     assert (off == reckeys->buf_used);
1886     iscz1_stop(decode_handle);
1887 }
1888 #else
1889 void extract_flushSortKeys (ZebraHandle zh, SYSNO sysno,
1890                             int cmd, struct sortKeys *sk)
1891 {
1892     SortIdx sortIdx = zh->reg->sortIdx;
1893     int off = 0;
1894
1895     sortIdx_sysno (sortIdx, sysno);
1896
1897     while (off < sk->buf_used)
1898     {
1899         int set, use, slen;
1900
1901         off += key_SU_decode(&set, (unsigned char *) sk->buf + off);
1902         off += key_SU_decode(&use, (unsigned char *) sk->buf + off);
1903         off += key_SU_decode(&slen, (unsigned char *) sk->buf + off);
1904
1905         sortIdx_type(sortIdx, use);
1906         if (cmd == 1)
1907             sortIdx_add(sortIdx, sk->buf + off, slen);
1908         else
1909             sortIdx_add(sortIdx, "", 1);
1910         off += slen;
1911     }
1912 }
1913 #endif
1914
1915 void encode_key_init (struct encode_info *i)
1916 {
1917     i->sysno = 0;
1918     i->seqno = 0;
1919     i->cmd = -1;
1920     i->prevsys=0;
1921     i->prevseq=0;
1922     i->prevcmd=-1;
1923     i->keylen=0;
1924     i->encode_handle = iscz1_start();
1925 }
1926
1927 #define OLDENCODE 1
1928
1929 #ifdef OLDENCODE
1930 /* this is the old encode_key_write
1931  * may be deleted once we are confident that the new works
1932  * HL 15-oct-2002
1933  */
1934 void encode_key_write (char *k, struct encode_info *i, FILE *outf)
1935 {
1936     struct it_key key;
1937     char *bp = i->buf, *bp0;
1938     const char *src = (char *) &key;
1939
1940     /* copy term to output buf */
1941     while ((*bp++ = *k++))
1942         ;
1943     /* and copy & align key so we can mangle */
1944     memcpy (&key, k+1, sizeof(struct it_key));  /* *k is insert/delete */
1945
1946     bp0 = bp++;
1947     iscz1_encode(i->encode_handle, &bp, &src);
1948     *bp0 = (*k * 128) + bp - bp0 - 1; /* length and insert/delete combined */
1949     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
1950     {
1951         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fwrite");
1952         exit (1);
1953     }
1954 }
1955
1956 void encode_key_flush (struct encode_info *i, FILE *outf)
1957 { /* dummy routine */
1958     iscz1_stop(i->encode_handle);
1959 }
1960
1961 #else
1962
1963 /* new encode_key_write
1964  * The idea is to buffer one more key, and compare them
1965  * If we are going to delete and insert the same key,
1966  * we may as well not bother. Should make a difference in
1967  * updates with small modifications (appending to a mbox)
1968  */
1969 void encode_key_write (char *k, struct encode_info *i, FILE *outf)
1970 {
1971     struct it_key key;
1972     char *bp;
1973
1974     if (*k)  /* first time for new key */
1975     {
1976         bp = i->buf;
1977         while ((*bp++ = *k++))
1978             ;
1979         i->keylen= bp - i->buf -1;
1980         assert(i->keylen+1+sizeof(struct it_key) < ENCODE_BUFLEN);
1981     }
1982     else
1983     {
1984         bp=i->buf + i->keylen;
1985         *bp++=0;
1986         k++;
1987     }
1988
1989     memcpy (&key, k+1, sizeof(struct it_key));
1990     if (0==i->prevsys) /* no previous filter, fill up */
1991     {
1992         i->prevsys=key.sysno;
1993         i->prevseq=key.seqno;
1994         i->prevcmd=*k;
1995     }
1996     else if ( (i->prevsys==key.sysno) &&
1997               (i->prevseq==key.seqno) &&
1998               (i->prevcmd!=*k) )
1999     { /* same numbers, diff cmd, they cancel out */
2000         i->prevsys=0;
2001     }
2002     else
2003     { /* different stuff, write previous, move buf */
2004         bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
2005         if (i->sysno != i->prevsys)
2006         {
2007             i->sysno = i->prevsys;
2008             i->seqno = 0;
2009         }
2010         else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
2011         {
2012             return; /* ??? Filters some sort of duplicates away */
2013                     /* ??? Can this ever happen   -H 15oct02 */
2014         }
2015         bp = encode_key_int (i->prevseq - i->seqno, bp);
2016         i->seqno = i->prevseq;
2017         i->cmd = i->prevcmd;
2018         if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
2019         {
2020             yaz_log (YLOG_FATAL|YLOG_ERRNO, "fwrite");
2021             exit (1);
2022         }
2023         i->keylen=0; /* ok, it's written, forget it */
2024         i->prevsys=key.sysno;
2025         i->prevseq=key.seqno;
2026         i->prevcmd=*k;
2027     }
2028 }
2029
2030 void encode_key_flush (struct encode_info *i, FILE *outf)
2031 { /* flush the last key from i */
2032     char *bp =i->buf + i->keylen;
2033     if (0==i->prevsys)
2034     {
2035         return; /* nothing to flush */
2036     }
2037     *bp++=0;
2038     bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
2039     if (i->sysno != i->prevsys)
2040     {
2041         i->sysno = i->prevsys;
2042         i->seqno = 0;
2043     }
2044     else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
2045     {
2046         return; /* ??? Filters some sort of duplicates away */
2047                 /* ??? Can this ever happen   -H 15oct02 */
2048     }
2049     bp = encode_key_int (i->prevseq - i->seqno, bp);
2050     i->seqno = i->prevseq;
2051     i->cmd = i->prevcmd;
2052     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
2053     {
2054         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fwrite");
2055         exit (1);
2056     }
2057     i->keylen=0; /* ok, it's written, forget it */
2058     i->prevsys=0; /* forget the values too */
2059     i->prevseq=0;
2060 }
2061 #endif