index/extract.c

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