index/extract.c

   1 /* $Id: extract.c,v 1.124 2002-10-16 09:30:57 heikki 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 = 8*1024*1024;
1226         zh->reg->key_buf = (char**) xmalloc (mem);
1227         zh->reg->ptr_top = mem/sizeof(char*);
1228         zh->reg->ptr_i = 0;
1229         zh->reg->key_buf_used = 0;
1230         zh->reg->key_file_no = 0;
1231     }
1232     zebraExplain_recordCountIncrement (zei, cmd ? 1 : -1);
1233     while (off < reckeys->buf_used)
1234     {
1235         const char *src = reckeys->buf + off;
1236         struct it_key key;
1237         int lead;
1238
1239         lead = *src++;
1240
1241 #if SU_SCHEME
1242         if ((lead & 3) < 3)
1243         {
1244             memcpy (&ch, src, sizeof(ch));
1245             src += sizeof(ch);
1246         }
1247 #else
1248         if (!(lead & 1))
1249         {
1250             memcpy (&attrSet, src, sizeof(attrSet));
1251             src += sizeof(attrSet);
1252         }
1253         if (!(lead & 2))
1254         {
1255             memcpy (&attrUse, src, sizeof(attrUse));
1256             src += sizeof(attrUse);
1257         }
1258 #endif
1259         if (zh->reg->key_buf_used + 1024 >
1260             (zh->reg->ptr_top -zh->reg->ptr_i)*sizeof(char*))
1261             extract_flushWriteKeys (zh);
1262         ++(zh->reg->ptr_i);
1263         (zh->reg->key_buf)[zh->reg->ptr_top - zh->reg->ptr_i] =
1264             (char*)zh->reg->key_buf + zh->reg->key_buf_used;
1265 #if SU_SCHEME
1266 #else
1267         ch = zebraExplain_lookupSU (zei, attrSet, attrUse);
1268         if (ch < 0)
1269             ch = zebraExplain_addSU (zei, attrSet, attrUse);
1270 #endif
1271         assert (ch > 0);
1272         zh->reg->key_buf_used +=
1273             key_SU_encode (ch,((char*)zh->reg->key_buf) +
1274                            zh->reg->key_buf_used);
1275
1276         while (*src)
1277             ((char*)zh->reg->key_buf) [(zh->reg->key_buf_used)++] = *src++;
1278         src++;
1279         ((char*)(zh->reg->key_buf))[(zh->reg->key_buf_used)++] = '\0';
1280         ((char*)(zh->reg->key_buf))[(zh->reg->key_buf_used)++] = cmd;
1281
1282         if (lead & 60)
1283             seqno += ((lead>>2) & 15)-1;
1284         else
1285         {
1286             memcpy (&seqno, src, sizeof(seqno));
1287             src += sizeof(seqno);
1288         }
1289         key.seqno = seqno;
1290         key.sysno = sysno;
1291         memcpy ((char*)zh->reg->key_buf + zh->reg->key_buf_used, &key, sizeof(key));
1292         (zh->reg->key_buf_used) += sizeof(key);
1293         off = src - reckeys->buf;
1294     }
1295     assert (off == reckeys->buf_used);
1296 }
1297
1298 void extract_flushWriteKeys (ZebraHandle zh)
1299 {
1300     FILE *outf;
1301     char out_fname[200];
1302     char *prevcp, *cp;
1303     struct encode_info encode_info;
1304     int ptr_i = zh->reg->ptr_i;
1305 #if SORT_EXTRA
1306     int i;
1307 #endif
1308     if (!zh->reg->key_buf || ptr_i <= 0)
1309         return;
1310
1311     (zh->reg->key_file_no)++;
1312     logf (LOG_LOG, "sorting section %d", (zh->reg->key_file_no));
1313 #if !SORT_EXTRA
1314     qsort (zh->reg->key_buf + zh->reg->ptr_top - ptr_i, ptr_i,
1315                sizeof(char*), key_qsort_compare);
1316     extract_get_fname_tmp (zh, out_fname, zh->reg->key_file_no);
1317
1318     if (!(outf = fopen (out_fname, "wb")))
1319     {
1320         logf (LOG_FATAL|LOG_ERRNO, "fopen %s", out_fname);
1321         exit (1);
1322     }
1323     logf (LOG_LOG, "writing section %d", zh->reg->key_file_no);
1324     prevcp = cp = (zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
1325
1326     encode_key_init (&encode_info);
1327     encode_key_write (cp, &encode_info, outf);
1328
1329     while (--ptr_i > 0)
1330     {
1331         cp = (zh->reg->key_buf)[zh->reg->ptr_top - ptr_i];
1332         if (strcmp (cp, prevcp))
1333         {
1334             encode_key_flush ( &encode_info, outf);
1335             encode_key_init (&encode_info);
1336             encode_key_write (cp, &encode_info, outf);
1337             prevcp = cp;
1338         }
1339         else
1340             encode_key_write (cp + strlen(cp), &encode_info, outf);
1341     }
1342     encode_key_flush ( &encode_info, outf);
1343 #else
1344     qsort (key_buf + ptr_top-ptr_i, ptr_i, sizeof(char*), key_x_compare);
1345     extract_get_fname_tmp (out_fname, key_file_no);
1346
1347     if (!(outf = fopen (out_fname, "wb")))
1348     {
1349         logf (LOG_FATAL|LOG_ERRNO, "fopen %s", out_fname);
1350         exit (1);
1351     }
1352     logf (LOG_LOG, "writing section %d", key_file_no);
1353     i = ptr_i;
1354     prevcp =  key_buf[ptr_top-i];
1355     while (1)
1356         if (!--i || strcmp (prevcp, key_buf[ptr_top-i]))
1357         {
1358             key_y_len = strlen(prevcp)+1;
1359 #if 0
1360             logf (LOG_LOG, "key_y_len: %2d %02x %02x %s",
1361                       key_y_len, prevcp[0], prevcp[1], 2+prevcp);
1362 #endif
1363             qsort (key_buf + ptr_top-ptr_i, ptr_i - i,
1364                                    sizeof(char*), key_y_compare);
1365             cp = key_buf[ptr_top-ptr_i];
1366             --key_y_len;
1367             encode_key_init (&encode_info);
1368             encode_key_write (cp, &encode_info, outf);
1369             while (--ptr_i > i)
1370             {
1371                 cp = key_buf[ptr_top-ptr_i];
1372                 encode_key_write (cp+key_y_len, &encode_info, outf);
1373             }
1374             encode_key_flush ( &encode_info, outf);
1375             if (!i)
1376                 break;
1377             prevcp = key_buf[ptr_top-ptr_i];
1378         }
1379 #endif
1380     if (fclose (outf))
1381     {
1382         logf (LOG_FATAL|LOG_ERRNO, "fclose %s", out_fname);
1383         exit (1);
1384     }
1385     logf (LOG_LOG, "finished section %d", zh->reg->key_file_no);
1386     zh->reg->ptr_i = 0;
1387     zh->reg->key_buf_used = 0;
1388 }
1389
1390 void extract_add_index_string (RecWord *p, const char *string,
1391                                int length)
1392 {
1393     char *dst;
1394     unsigned char attrSet;
1395     unsigned short attrUse;
1396     int lead = 0;
1397     int diff = 0;
1398     int *pseqno = &p->seqno;
1399     ZebraHandle zh = p->extractCtrl->handle;
1400     ZebraExplainInfo zei = zh->reg->zei;
1401     struct recKeys *keys = &zh->reg->keys;
1402
1403     if (keys->buf_used+1024 > keys->buf_max)
1404     {
1405         char *b;
1406
1407         b = (char *) xmalloc (keys->buf_max += 128000);
1408         if (keys->buf_used > 0)
1409             memcpy (b, keys->buf, keys->buf_used);
1410         xfree (keys->buf);
1411         keys->buf = b;
1412     }
1413     dst = keys->buf + keys->buf_used;
1414
1415     attrSet = p->attrSet;
1416     if (keys->buf_used > 0 && keys->prevAttrSet == attrSet)
1417         lead |= 1;
1418     else
1419         keys->prevAttrSet = attrSet;
1420     attrUse = p->attrUse;
1421     if (keys->buf_used > 0 && keys->prevAttrUse == attrUse)
1422         lead |= 2;
1423     else
1424         keys->prevAttrUse = attrUse;
1425 #if 1
1426     diff = 1 + *pseqno - keys->prevSeqNo;
1427     if (diff >= 1 && diff <= 15)
1428         lead |= (diff << 2);
1429     else
1430         diff = 0;
1431 #endif
1432     keys->prevSeqNo = *pseqno;
1433
1434     *dst++ = lead;
1435
1436 #if SU_SCHEME
1437     if ((lead & 3) < 3)
1438     {
1439         int ch = zebraExplain_lookupSU (zei, attrSet, attrUse);
1440         if (ch < 0)
1441         {
1442             ch = zebraExplain_addSU (zei, attrSet, attrUse);
1443             yaz_log (LOG_DEBUG, "addSU set=%d use=%d SU=%d",
1444                      attrSet, attrUse, ch);
1445         }
1446         assert (ch > 0);
1447         memcpy (dst, &ch, sizeof(ch));
1448         dst += sizeof(ch);
1449     }
1450 #else
1451     if (!(lead & 1))
1452     {
1453         memcpy (dst, &attrSet, sizeof(attrSet));
1454         dst += sizeof(attrSet);
1455     }
1456     if (!(lead & 2))
1457     {
1458         memcpy (dst, &attrUse, sizeof(attrUse));
1459         dst += sizeof(attrUse);
1460     }
1461 #endif
1462     *dst++ = p->reg_type;
1463     memcpy (dst, string, length);
1464     dst += length;
1465     *dst++ = '\0';
1466
1467     if (!diff)
1468     {
1469         memcpy (dst, pseqno, sizeof(*pseqno));
1470         dst += sizeof(*pseqno);
1471     }
1472     keys->buf_used = dst - keys->buf;
1473 }
1474
1475 static void extract_add_sort_string (RecWord *p, const char *string,
1476                                      int length)
1477 {
1478     struct sortKey *sk;
1479     ZebraHandle zh = p->extractCtrl->handle;
1480
1481     for (sk = zh->reg->sortKeys; sk; sk = sk->next)
1482         if (sk->attrSet == p->attrSet && sk->attrUse == p->attrUse)
1483             return;
1484
1485     sk = (struct sortKey *) xmalloc (sizeof(*sk));
1486     sk->next = zh->reg->sortKeys;
1487     zh->reg->sortKeys = sk;
1488
1489     sk->string = (char *) xmalloc (length);
1490     sk->length = length;
1491     memcpy (sk->string, string, length);
1492
1493     sk->attrSet = p->attrSet;
1494     sk->attrUse = p->attrUse;
1495 }
1496
1497 void extract_add_string (RecWord *p, const char *string, int length)
1498 {
1499     assert (length > 0);
1500     if (zebra_maps_is_sort (p->zebra_maps, p->reg_type))
1501         extract_add_sort_string (p, string, length);
1502     else
1503         extract_add_index_string (p, string, length);
1504 }
1505
1506 static void extract_add_incomplete_field (RecWord *p)
1507 {
1508     const char *b = p->string;
1509     int remain = p->length;
1510     const char **map = 0;
1511
1512     if (remain > 0)
1513         map = zebra_maps_input(p->zebra_maps, p->reg_type, &b, remain);
1514
1515     while (map)
1516     {
1517         char buf[IT_MAX_WORD+1];
1518         int i, remain;
1519
1520         /* Skip spaces */
1521         while (map && *map && **map == *CHR_SPACE)
1522         {
1523             remain = p->length - (b - p->string);
1524             if (remain > 0)
1525                 map = zebra_maps_input(p->zebra_maps, p->reg_type, &b, remain);
1526             else
1527                 map = 0;
1528         }
1529         if (!map)
1530             break;
1531         i = 0;
1532         while (map && *map && **map != *CHR_SPACE)
1533         {
1534             const char *cp = *map;
1535
1536             while (i < IT_MAX_WORD && *cp)
1537                 buf[i++] = *(cp++);
1538             remain = p->length - (b - p->string);
1539             if (remain > 0)
1540                 map = zebra_maps_input(p->zebra_maps, p->reg_type, &b, remain);
1541             else
1542                 map = 0;
1543         }
1544         if (!i)
1545             return;
1546         extract_add_string (p, buf, i);
1547         p->seqno++;
1548     }
1549 }
1550
1551 static void extract_add_complete_field (RecWord *p)
1552 {
1553     const char *b = p->string;
1554     char buf[IT_MAX_WORD+1];
1555     const char **map = 0;
1556     int i = 0, remain = p->length;
1557
1558     if (remain > 0)
1559         map = zebra_maps_input (p->zebra_maps, p->reg_type, &b, remain);
1560
1561     while (remain > 0 && i < IT_MAX_WORD)
1562     {
1563         while (map && *map && **map == *CHR_SPACE)
1564         {
1565             remain = p->length - (b - p->string);
1566             if (remain > 0)
1567                 map = zebra_maps_input(p->zebra_maps, p->reg_type, &b, remain);
1568             else
1569                 map = 0;
1570         }
1571         if (!map)
1572             break;
1573
1574         if (i && i < IT_MAX_WORD)
1575             buf[i++] = *CHR_SPACE;
1576         while (map && *map && **map != *CHR_SPACE)
1577         {
1578             const char *cp = *map;
1579
1580             if (i >= IT_MAX_WORD)
1581                 break;
1582             while (i < IT_MAX_WORD && *cp)
1583                 buf[i++] = *(cp++);
1584             remain = p->length  - (b - p->string);
1585             if (remain > 0)
1586                 map = zebra_maps_input (p->zebra_maps, p->reg_type, &b,
1587                                         remain);
1588             else
1589                 map = 0;
1590         }
1591     }
1592     if (!i)
1593         return;
1594     extract_add_string (p, buf, i);
1595 }
1596
1597 void extract_token_add (RecWord *p)
1598 {
1599     WRBUF wrbuf;
1600     if ((wrbuf = zebra_replace(p->zebra_maps, p->reg_type, 0,
1601                                p->string, p->length)))
1602     {
1603         p->string = wrbuf_buf(wrbuf);
1604         p->length = wrbuf_len(wrbuf);
1605     }
1606     if (zebra_maps_is_complete (p->zebra_maps, p->reg_type))
1607         extract_add_complete_field (p);
1608     else
1609         extract_add_incomplete_field(p);
1610 }
1611
1612 void extract_schema_add (struct recExtractCtrl *p, Odr_oid *oid)
1613 {
1614     ZebraHandle zh = (ZebraHandle) (p->handle);
1615     zebraExplain_addSchema (zh->reg->zei, oid);
1616 }
1617
1618 void extract_flushSortKeys (ZebraHandle zh, SYSNO sysno,
1619                             int cmd, struct sortKey **skp)
1620 {
1621     struct sortKey *sk = *skp;
1622     SortIdx sortIdx = zh->reg->sortIdx;
1623
1624     sortIdx_sysno (sortIdx, sysno);
1625     while (sk)
1626     {
1627         struct sortKey *sk_next = sk->next;
1628         sortIdx_type (sortIdx, sk->attrUse);
1629         sortIdx_add (sortIdx, sk->string, sk->length);
1630         xfree (sk->string);
1631         xfree (sk);
1632         sk = sk_next;
1633     }
1634     *skp = 0;
1635 }
1636
1637 void encode_key_init (struct encode_info *i)
1638 {
1639     i->sysno = 0;
1640     i->seqno = 0;
1641     i->cmd = -1;
1642     i->prevsys=0;
1643     i->prevseq=0;
1644     i->prevcmd=-1;
1645     i->keylen=0;
1646 }
1647
1648 char *encode_key_int (int d, char *bp)
1649 {
1650     if (d <= 63)
1651         *bp++ = d;
1652     else if (d <= 16383)
1653     {
1654         *bp++ = 64 + (d>>8);
1655         *bp++ = d  & 255;
1656     }
1657     else if (d <= 4194303)
1658     {
1659         *bp++ = 128 + (d>>16);
1660         *bp++ = (d>>8) & 255;
1661         *bp++ = d & 255;
1662     }
1663     else
1664     {
1665         *bp++ = 192 + (d>>24);
1666         *bp++ = (d>>16) & 255;
1667         *bp++ = (d>>8) & 255;
1668         *bp++ = d & 255;
1669     }
1670     return bp;
1671 }
1672
1673 #ifdef OLDENCODE
1674 /* this is the old encode_key_write
1675  * may be deleted once we are confident that the new works
1676  * HL 15-oct-2002
1677  */
1678 void encode_key_write (char *k, struct encode_info *i, FILE *outf)
1679 {
1680     struct it_key key;
1681     char *bp = i->buf;
1682
1683     while ((*bp++ = *k++))
1684         ;
1685     memcpy (&key, k+1, sizeof(struct it_key));
1686     bp = encode_key_int ( (key.sysno - i->sysno) * 2 + *k, bp);
1687     if (i->sysno != key.sysno)
1688     {
1689         i->sysno = key.sysno;
1690         i->seqno = 0;
1691     }
1692     else if (!i->seqno && !key.seqno && i->cmd == *k)
1693         return;
1694     bp = encode_key_int (key.seqno - i->seqno, bp);
1695     i->seqno = key.seqno;
1696     i->cmd = *k;
1697     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
1698     {
1699         logf (LOG_FATAL|LOG_ERRNO, "fwrite");
1700         exit (1);
1701     }
1702 }
1703
1704 void encode_key_flush (struct encode_info *i, FILE *outf)
1705 { /* dummy routine */
1706 }
1707
1708 #else
1709
1710 /* new encode_key_write
1711  * The idea is to buffer one more key, and compare them
1712  * If we are going to delete and insert the same key,
1713  * we may as well not bother. Should make a difference in
1714  * updates with small modifications (appending to a mbox)
1715  */
1716 void encode_key_write (char *k, struct encode_info *i, FILE *outf)
1717 {
1718     struct it_key key;
1719     char *bp;
1720
1721     if (*k)  /* first time for new key */
1722     {
1723         bp = i->buf;
1724         while ((*bp++ = *k++))
1725             ;
1726         i->keylen= bp - i->buf -1;
1727     }
1728     else
1729     {
1730         bp=i->buf + i->keylen;
1731         *bp++=0;
1732         k++;
1733     }
1734
1735     memcpy (&key, k+1, sizeof(struct it_key));
1736     if (0==i->prevsys) /* no previous filter, fill up */
1737     {
1738         i->prevsys=key.sysno;
1739         i->prevseq=key.seqno;
1740         i->prevcmd=*k;
1741     }
1742     else if ( (i->prevsys==key.sysno) &&
1743               (i->prevseq==key.seqno) &&
1744               (i->prevcmd!=*k) )
1745     { /* same numbers, diff cmd, they cancel out */
1746         i->prevsys=0;
1747     }
1748     else
1749     { /* different stuff, write previous, move buf */
1750         bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
1751         if (i->sysno != i->prevsys)
1752         {
1753             i->sysno = i->prevsys;
1754             i->seqno = 0;
1755         }
1756         else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
1757         {
1758             return; /* ??? Filters some sort of duplicates away */
1759                     /* ??? Can this ever happen   -H 15oct02 */
1760         }
1761         bp = encode_key_int (i->prevseq - i->seqno, bp);
1762         i->seqno = i->prevseq;
1763         i->cmd = i->prevcmd;
1764         if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
1765         {
1766             logf (LOG_FATAL|LOG_ERRNO, "fwrite");
1767             exit (1);
1768         }
1769         i->keylen=0; /* ok, it's written, forget it */
1770         i->prevsys=key.sysno;
1771         i->prevseq=key.seqno;
1772         i->prevcmd=*k;
1773     }
1774 #ifdef SKIPTHIS_OLDCODE
1775     bp = encode_key_int ( (key.sysno - i->sysno) * 2 + *k, bp);
1776     if (i->sysno != key.sysno)
1777     {
1778         i->sysno = key.sysno;
1779         i->seqno = 0;
1780     }
1781     else if (!i->seqno && !key.seqno && i->cmd == *k)
1782         return;
1783     bp = encode_key_int (key.seqno - i->seqno, bp);
1784     i->seqno = key.seqno;
1785     i->cmd = *k;
1786     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
1787     {
1788         logf (LOG_FATAL|LOG_ERRNO, "fwrite");
1789         exit (1);
1790     }
1791     i->keylen=0; /* ok, it's written, forget it */
1792 #endif
1793 }
1794
1795 void encode_key_flush (struct encode_info *i, FILE *outf)
1796 { /* flush the last key from i */
1797     char *bp =i->buf + i->keylen;
1798     if (0==i->prevsys)
1799     {
1800         return; /* nothing to flush */
1801     }
1802     *bp++=0;
1803     bp = encode_key_int ( (i->prevsys - i->sysno) * 2 + i->prevcmd, bp);
1804     if (i->sysno != i->prevsys)
1805     {
1806         i->sysno = i->prevsys;
1807         i->seqno = 0;
1808     }
1809     else if (!i->seqno && !i->prevseq && i->cmd == i->prevcmd)
1810     {
1811         return; /* ??? Filters some sort of duplicates away */
1812                 /* ??? Can this ever happen   -H 15oct02 */
1813     }
1814     bp = encode_key_int (i->prevseq - i->seqno, bp);
1815     i->seqno = i->prevseq;
1816     i->cmd = i->prevcmd;
1817     if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
1818     {
1819         logf (LOG_FATAL|LOG_ERRNO, "fwrite");
1820         exit (1);
1821     }
1822     i->keylen=0; /* ok, it's written, forget it */
1823     i->prevsys=0; /* forget the values too */
1824     i->prevseq=0;
1825 }
1826 #endif