index/extract.c

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