index/zinfo.c

   1 /*
   2  * Copyright (C) 1994-2002, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Id: zinfo.c,v 1.24 2002-02-20 23:07:54 adam Exp $
   7  */
   8
   9 #include <stdlib.h>
  10 #include <assert.h>
  11 #include <string.h>
  12 #include <time.h>
  13
  14 #include <zebraver.h>
  15 #include "zinfo.h"
  16
  17 #define ZINFO_DEBUG 0
  18
  19 struct zebSUInfo {
  20     int set;
  21     int use;
  22     int ordinal;
  23 };
  24
  25 struct zebSUInfoB {
  26     struct zebSUInfo info;
  27     struct zebSUInfoB *next;
  28 };
  29
  30 typedef struct zebAccessObjectB *zebAccessObject;
  31 struct zebAccessObjectB {
  32     void *handle;
  33     int sysno;
  34     Odr_oid *oid;
  35     zebAccessObject next;
  36 };
  37
  38 typedef struct zebAccessInfoB *zebAccessInfo;
  39 struct zebAccessInfoB {
  40     zebAccessObject attributeSetIds;
  41     zebAccessObject schemas;
  42 };
  43
  44 typedef struct {
  45     struct zebSUInfoB *SUInfo;
  46     int sysno;
  47     int dirty;
  48     int readFlag;
  49     data1_node *data1_tree;
  50 } *zebAttributeDetails;
  51
  52 struct zebDatabaseInfoB {
  53     zebAttributeDetails attributeDetails;
  54     char *databaseName;
  55     data1_node *data1_database;
  56     int recordCount;     /* records in db */
  57     int recordBytes;     /* size of records */
  58     int sysno;           /* sysno of database info */
  59     int readFlag;        /* 1: read is needed when referenced; 0 if not */
  60     int dirty;           /* 1: database is dirty: write is needed */
  61     struct zebDatabaseInfoB *next;
  62     zebAccessInfo accessInfo;
  63 };
  64
  65 struct zebraExplainAttset {
  66     char *name;
  67     int ordinal;
  68     struct zebraExplainAttset *next;
  69 };
  70
  71 struct zebraCategoryListInfo {
  72     int dirty;
  73     int sysno;
  74     data1_node *data1_categoryList;
  75 };
  76
  77 struct zebraExplainInfo {
  78     int  ordinalSU;
  79     int  runNumber;
  80     int  dirty;
  81     Records records;
  82     data1_handle dh;
  83     Res res;
  84     struct zebraExplainAttset *attsets;
  85     NMEM nmem;
  86     data1_node *data1_target;
  87     struct zebraCategoryListInfo *categoryList;
  88     struct zebDatabaseInfoB *databaseInfo;
  89     struct zebDatabaseInfoB *curDatabaseInfo;
  90     zebAccessInfo accessInfo;
  91     char date[15]; /* YYYY MMDD HH MM SS */
  92     int (*updateFunc)(void *handle, Record drec, data1_node *n);
  93     void *updateHandle;
  94 };
  95
  96 static void zebraExplain_initCommonInfo (ZebraExplainInfo zei, data1_node *n);
  97 static void zebraExplain_initAccessInfo (ZebraExplainInfo zei, data1_node *n);
  98
  99 static data1_node *read_sgml_rec (data1_handle dh, NMEM nmem, Record rec)
 100 {
 101     return data1_read_sgml (dh, nmem, rec->info[recInfo_storeData]);
 102 }
 103
 104 static data1_node *data1_search_tag (data1_handle dh, data1_node *n,
 105                                     const char *tag)
 106 {
 107     logf (LOG_DEBUG, "data1_search_tag %s", tag);
 108     for (; n; n = n->next)
 109         if (n->which == DATA1N_tag && n->u.tag.tag &&
 110             !yaz_matchstr (tag, n->u.tag.tag))
 111         {
 112             logf (LOG_DEBUG, " found");
 113             return n;
 114         }
 115     logf (LOG_DEBUG, " not found");
 116     return 0;
 117 }
 118
 119 static data1_node *data1_add_tag (data1_handle dh, data1_node *at,
 120                                   const char *tag, NMEM nmem)
 121 {
 122     data1_node *partag = get_parent_tag(dh, at);
 123     data1_node *res = data1_mk_node_type (dh, nmem, DATA1N_tag);
 124     data1_element *e = NULL;
 125
 126     res->parent = at;
 127     res->u.tag.tag = data1_insert_string (dh, res, nmem, tag);
 128
 129     if (partag)
 130         e = partag->u.tag.element;
 131     res->u.tag.element =
 132         data1_getelementbytagname (dh, at->root->u.root.absyn,
 133                                    e, res->u.tag.tag);
 134     res->root = at->root;
 135     if (!at->child)
 136         at->child = res;
 137     else
 138     {
 139         assert (at->last_child);
 140         at->last_child->next = res;
 141     }
 142     at->last_child = res;
 143     return res;
 144 }
 145
 146 static data1_node *data1_make_tag (data1_handle dh, data1_node *at,
 147                                    const char *tag, NMEM nmem)
 148 {
 149     data1_node *node = data1_search_tag (dh, at->child, tag);
 150     if (!node)
 151         node = data1_add_tag (dh, at, tag, nmem);
 152     else
 153         node->child = node->last_child = NULL;
 154     return node;
 155 }
 156
 157 static data1_node *data1_add_tagdata_int (data1_handle dh, data1_node *at,
 158                                           const char *tag, int num,
 159                                           NMEM nmem)
 160 {
 161     data1_node *node_data;
 162
 163     node_data = data1_add_taggeddata (dh, at->root, at, tag, nmem);
 164     if (!node_data)
 165         return 0;
 166     node_data->u.data.what = DATA1I_num;
 167     node_data->u.data.data = node_data->lbuf;
 168     sprintf (node_data->u.data.data, "%d", num);
 169     node_data->u.data.len = strlen (node_data->u.data.data);
 170     return node_data;
 171 }
 172
 173 static data1_node *data1_add_tagdata_oid (data1_handle dh, data1_node *at,
 174                                            const char *tag, Odr_oid *oid,
 175                                            NMEM nmem)
 176 {
 177     data1_node *node_data;
 178     char str[128], *p = str;
 179     Odr_oid *ii;
 180
 181     node_data = data1_add_taggeddata (dh, at->root, at, tag, nmem);
 182     if (!node_data)
 183         return 0;
 184
 185     for (ii = oid; *ii >= 0; ii++)
 186     {
 187         if (ii != oid)
 188             *p++ = '.';
 189         sprintf (p, "%d", *ii);
 190         p += strlen (p);
 191     }
 192     node_data->u.data.what = DATA1I_oid;
 193     node_data->u.data.len = strlen (str);
 194     node_data->u.data.data = data1_insert_string (dh, node_data, nmem, str);
 195     return node_data;
 196 }
 197
 198
 199 static data1_node *data1_add_tagdata_text (data1_handle dh, data1_node *at,
 200                                            const char *tag, const char *str,
 201                                            NMEM nmem)
 202 {
 203     data1_node *node_data;
 204
 205     node_data = data1_add_taggeddata (dh, at->root, at, tag, nmem);
 206     if (!node_data)
 207         return 0;
 208     node_data->u.data.what = DATA1I_text;
 209     node_data->u.data.len = strlen (str);
 210     node_data->u.data.data = data1_insert_string (dh, node_data, nmem, str);
 211     return node_data;
 212 }
 213
 214 static data1_node *data1_make_tagdata_text (data1_handle dh, data1_node *at,
 215                                             const char *tag, const char *str,
 216                                             NMEM nmem)
 217 {
 218     data1_node *node = data1_search_tag (dh, at->child, tag);
 219     if (!node)
 220         return data1_add_tagdata_text (dh, at, tag, str, nmem);
 221     else
 222     {
 223         data1_node *node_data = node->child;
 224         node_data->u.data.what = DATA1I_text;
 225         node_data->u.data.len = strlen (str);
 226         node_data->u.data.data = data1_insert_string (dh, node_data,
 227                                                       nmem, str);
 228         return node_data;
 229     }
 230 }
 231
 232 static void zebraExplain_writeDatabase (ZebraExplainInfo zei,
 233                                         struct zebDatabaseInfoB *zdi,
 234                                         int key_flush);
 235 static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei,
 236                                                 zebAttributeDetails zad,
 237                                                 const char *databaseName,
 238                                                 int key_flush);
 239 static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush);
 240 static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei,
 241                                             zebAccessObject o,
 242                                             int key_flush);
 243 static void zebraExplain_writeCategoryList (ZebraExplainInfo zei,
 244                                             struct zebraCategoryListInfo *zcl,
 245                                             int key_flush);
 246
 247
 248 static Record createRecord (Records records, int *sysno)
 249 {
 250     Record rec;
 251     if (*sysno)
 252     {
 253         rec = rec_get (records, *sysno);
 254         xfree (rec->info[recInfo_storeData]);
 255     }
 256     else
 257     {
 258         rec = rec_new (records);
 259         *sysno = rec->sysno;
 260
 261         rec->info[recInfo_fileType] =
 262             rec_strdup ("grs.sgml", &rec->size[recInfo_fileType]);
 263         rec->info[recInfo_databaseName] =
 264             rec_strdup ("IR-Explain-1",
 265                         &rec->size[recInfo_databaseName]);
 266     }
 267     return rec;
 268 }
 269
 270 void zebraExplain_flush (ZebraExplainInfo zei, int writeFlag, void *handle)
 271 {
 272     if (!zei)
 273         return;
 274     zei->updateHandle = handle;
 275     if (writeFlag)
 276     {
 277         struct zebDatabaseInfoB *zdi;
 278         zebAccessObject o;
 279
 280         /* write each database info record */
 281         for (zdi = zei->databaseInfo; zdi; zdi = zdi->next)
 282         {
 283             zebraExplain_writeDatabase (zei, zdi, 1);
 284             zebraExplain_writeAttributeDetails (zei, zdi->attributeDetails,
 285                                                 zdi->databaseName, 1);
 286         }
 287         zebraExplain_writeTarget (zei, 1);
 288         zebraExplain_writeCategoryList (zei,
 289                                         zei->categoryList,
 290                                         1);
 291         assert (zei->accessInfo);
 292         for (o = zei->accessInfo->attributeSetIds; o; o = o->next)
 293             if (!o->sysno)
 294                 zebraExplain_writeAttributeSet (zei, o, 1);
 295         for (o = zei->accessInfo->schemas; o; o = o->next)
 296             if (!o->sysno)
 297             {
 298 /*              zebraExplain_writeSchema (zei, o, 1); */
 299             }
 300
 301         for (zdi = zei->databaseInfo; zdi; zdi = zdi->next)
 302         {
 303             zebraExplain_writeDatabase (zei, zdi, 0);
 304             zebraExplain_writeAttributeDetails (zei, zdi->attributeDetails,
 305                                                 zdi->databaseName, 0);
 306         }
 307         zebraExplain_writeTarget (zei, 0);
 308     }
 309 }
 310
 311 void zebraExplain_close (ZebraExplainInfo zei, int writeFlag)
 312 {
 313 #if ZINFO_DEBUG
 314     logf (LOG_LOG, "zebraExplain_close wr=%d", writeFlag);
 315 #endif
 316     if (!zei)
 317         return;
 318     zebraExplain_flush (zei, writeFlag, zei->updateHandle);
 319     nmem_destroy (zei->nmem);
 320 }
 321
 322 void zebraExplain_mergeOids (ZebraExplainInfo zei, data1_node *n,
 323                              zebAccessObject *op)
 324 {
 325     data1_node *np;
 326
 327     for (np = n->child; np; np = np->next)
 328     {
 329         char str[64];
 330         int len;
 331         Odr_oid *oid;
 332         zebAccessObject ao;
 333
 334         if (np->which != DATA1N_tag || strcmp (np->u.tag.tag, "oid"))
 335             continue;
 336         len = np->child->u.data.len;
 337         if (len > 63)
 338             len = 63;
 339         memcpy (str, np->child->u.data.data, len);
 340         str[len] = '\0';
 341
 342         oid = odr_getoidbystr_nmem (zei->nmem, str);
 343
 344         for (ao = *op; ao; ao = ao->next)
 345             if (!oid_oidcmp (oid, ao->oid))
 346             {
 347                 ao->sysno = 1;
 348                 break;
 349             }
 350         if (!ao)
 351         {
 352             ao = (zebAccessObject) nmem_malloc (zei->nmem, sizeof(*ao));
 353             ao->handle = NULL;
 354             ao->sysno = 1;
 355             ao->oid = oid;
 356             ao->next = *op;
 357             *op = ao;
 358         }
 359     }
 360 }
 361
 362 void zebraExplain_mergeAccessInfo (ZebraExplainInfo zei, data1_node *n,
 363                                    zebAccessInfo *accessInfo)
 364 {
 365     data1_node *np;
 366
 367     if (!n)
 368     {
 369         *accessInfo = (zebAccessInfo)
 370             nmem_malloc (zei->nmem, sizeof(**accessInfo));
 371         (*accessInfo)->attributeSetIds = NULL;
 372         (*accessInfo)->schemas = NULL;
 373     }
 374     else
 375     {
 376         if (!(n = data1_search_tag (zei->dh, n->child, "accessInfo")))
 377             return;
 378         if ((np = data1_search_tag (zei->dh, n->child, "attributeSetIds")))
 379             zebraExplain_mergeOids (zei, np,
 380                                     &(*accessInfo)->attributeSetIds);
 381         if ((np = data1_search_tag (zei->dh, n->child, "schemas")))
 382             zebraExplain_mergeOids (zei, np,
 383                                     &(*accessInfo)->schemas);
 384     }
 385 }
 386
 387 ZebraExplainInfo zebraExplain_open (
 388     Records records, data1_handle dh,
 389     Res res,
 390     int writeFlag,
 391     void *updateHandle,
 392     int (*updateFunc)(void *handle, Record drec, data1_node *n))
 393 {
 394     Record trec;
 395     ZebraExplainInfo zei;
 396     struct zebDatabaseInfoB **zdip;
 397     time_t our_time;
 398     struct tm *tm;
 399     NMEM nmem = nmem_create ();
 400
 401 #if ZINFO_DEBUG
 402     logf (LOG_LOG, "zebraExplain_open wr=%d", writeFlag);
 403 #endif
 404     zei = (ZebraExplainInfo) nmem_malloc (nmem, sizeof(*zei));
 405     zei->updateHandle = updateHandle;
 406     zei->updateFunc = updateFunc;
 407     zei->dirty = 0;
 408     zei->curDatabaseInfo = NULL;
 409     zei->records = records;
 410     zei->nmem = nmem;
 411     zei->dh = dh;
 412     zei->attsets = NULL;
 413     zei->res = res;
 414     zei->categoryList = (struct zebraCategoryListInfo *)
 415         nmem_malloc (zei->nmem, sizeof(*zei->categoryList));
 416     zei->categoryList->sysno = 0;
 417     zei->categoryList->dirty = 0;
 418     zei->categoryList->data1_categoryList = NULL;
 419
 420     time (&our_time);
 421     tm = localtime (&our_time);
 422     sprintf (zei->date, "%04d%02d%02d%02d%02d%02d",
 423              tm->tm_year+1900, tm->tm_mon+1,  tm->tm_mday,
 424              tm->tm_hour, tm->tm_min, tm->tm_sec);
 425
 426     zdip = &zei->databaseInfo;
 427     trec = rec_get (records, 1);      /* get "root" record */
 428
 429     zei->ordinalSU = 1;
 430     zei->runNumber = 0;
 431
 432     zebraExplain_mergeAccessInfo (zei, 0, &zei->accessInfo);
 433     if (trec)    /* targetInfo already exists ... */
 434     {
 435         data1_node *node_tgtinfo, *node_zebra, *node_list, *np;
 436
 437         zei->data1_target = read_sgml_rec (zei->dh, zei->nmem, trec);
 438         if (!zei->data1_target || !zei->data1_target->u.root.absyn)
 439         {
 440             logf (LOG_FATAL, "Explain schema missing. Check profilePath");
 441             nmem_destroy (zei->nmem);
 442             return 0;
 443         }
 444 #if ZINFO_DEBUG
 445         data1_pr_tree (zei->dh, zei->data1_target, stderr);
 446 #endif
 447         node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target->child,
 448                                          "targetInfo");
 449         zebraExplain_mergeAccessInfo (zei, node_tgtinfo,
 450                                       &zei->accessInfo);
 451
 452         node_zebra = data1_search_tag (zei->dh, node_tgtinfo->child,
 453                                        "zebraInfo");
 454         np = 0;
 455         if (node_zebra)
 456         {
 457             node_list = data1_search_tag (zei->dh, node_zebra->child,
 458                                           "databaseList");
 459             if (node_list)
 460                 np = node_list->child;
 461         }
 462         for (; np; np = np->next)
 463         {
 464             data1_node *node_name = NULL;
 465             data1_node *node_id = NULL;
 466             data1_node *node_aid = NULL;
 467             data1_node *np2;
 468             if (np->which != DATA1N_tag || strcmp (np->u.tag.tag, "database"))
 469                 continue;
 470             for (np2 = np->child; np2; np2 = np2->next)
 471             {
 472                 if (np2->which != DATA1N_tag)
 473                     continue;
 474                 if (!strcmp (np2->u.tag.tag, "name"))
 475                     node_name = np2->child;
 476                 else if (!strcmp (np2->u.tag.tag, "id"))
 477                     node_id = np2->child;
 478                 else if (!strcmp (np2->u.tag.tag, "attributeDetailsId"))
 479                     node_aid = np2->child;
 480             }
 481             assert (node_id && node_name && node_aid);
 482
 483             *zdip = (struct zebDatabaseInfoB *)
 484                 nmem_malloc (zei->nmem, sizeof(**zdip));
 485             (*zdip)->readFlag = 1;
 486             (*zdip)->dirty = 0;
 487             (*zdip)->data1_database = NULL;
 488             (*zdip)->recordCount = 0;
 489             (*zdip)->recordBytes = 0;
 490             zebraExplain_mergeAccessInfo (zei, 0, &(*zdip)->accessInfo);
 491
 492             (*zdip)->databaseName = (char *)
 493                 nmem_malloc (zei->nmem, 1+node_name->u.data.len);
 494             memcpy ((*zdip)->databaseName, node_name->u.data.data,
 495                     node_name->u.data.len);
 496             (*zdip)->databaseName[node_name->u.data.len] = '\0';
 497             (*zdip)->sysno = atoi_n (node_id->u.data.data,
 498                                      node_id->u.data.len);
 499             (*zdip)->attributeDetails = (zebAttributeDetails)
 500                 nmem_malloc (zei->nmem, sizeof(*(*zdip)->attributeDetails));
 501             (*zdip)->attributeDetails->sysno = atoi_n (node_aid->u.data.data,
 502                                                        node_aid->u.data.len);
 503             (*zdip)->attributeDetails->readFlag = 1;
 504             (*zdip)->attributeDetails->dirty = 0;
 505             (*zdip)->attributeDetails->SUInfo = NULL;
 506
 507             zdip = &(*zdip)->next;
 508         }
 509         if (node_zebra)
 510         {
 511             np = data1_search_tag (zei->dh, node_zebra->child,
 512                                    "ordinalSU");
 513             np = np->child;
 514             assert (np && np->which == DATA1N_data);
 515             zei->ordinalSU = atoi_n (np->u.data.data, np->u.data.len);
 516
 517             np = data1_search_tag (zei->dh, node_zebra->child,
 518                                    "runNumber");
 519             np = np->child;
 520             assert (np && np->which == DATA1N_data);
 521             zei->runNumber = atoi_n (np->u.data.data, np->u.data.len);
 522             *zdip = NULL;
 523         }
 524         rec_rm (&trec);
 525     }
 526     else  /* create initial targetInfo */
 527     {
 528         data1_node *node_tgtinfo;
 529
 530         *zdip = NULL;
 531         if (writeFlag)
 532         {
 533             char *sgml_buf;
 534             int sgml_len;
 535
 536             zei->data1_target =
 537                 data1_read_sgml (zei->dh, zei->nmem,
 538                                  "<explain><targetInfo>TargetInfo\n"
 539                                  "<name>Zebra</>\n"
 540                                  "<namedResultSets>1</>\n"
 541                                  "<multipleDBSearch>1</>\n"
 542                                  "<nicknames><name>Zebra</></>\n"
 543                                  "</></>\n" );
 544             if (!zei->data1_target || !zei->data1_target->u.root.absyn)
 545             {
 546                 logf (LOG_FATAL, "Explain schema missing. Check profilePath");
 547                 nmem_destroy (zei->nmem);
 548                 return 0;
 549             }
 550             node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target->child,
 551                                             "targetInfo");
 552             assert (node_tgtinfo);
 553
 554             zebraExplain_initCommonInfo (zei, node_tgtinfo);
 555             zebraExplain_initAccessInfo (zei, node_tgtinfo);
 556
 557             /* write now because we want to be sure about the sysno */
 558             trec = rec_new (records);
 559             trec->info[recInfo_fileType] =
 560                 rec_strdup ("grs.sgml", &trec->size[recInfo_fileType]);
 561             trec->info[recInfo_databaseName] =
 562                 rec_strdup ("IR-Explain-1", &trec->size[recInfo_databaseName]);
 563
 564             sgml_buf = data1_nodetoidsgml(dh, zei->data1_target, 0, &sgml_len);
 565             trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
 566             memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len);
 567             trec->size[recInfo_storeData] = sgml_len;
 568
 569             rec_put (records, &trec);
 570             rec_rm (&trec);
 571
 572         }
 573         zebraExplain_newDatabase (zei, "IR-Explain-1", 0);
 574
 575         if (!zei->categoryList->dirty)
 576         {
 577             struct zebraCategoryListInfo *zcl = zei->categoryList;
 578             data1_node *node_cl;
 579
 580             zcl->dirty = 1;
 581             zcl->data1_categoryList =
 582                 data1_read_sgml (zei->dh, zei->nmem,
 583                                  "<explain><categoryList>CategoryList\n"
 584                                  "</></>\n");
 585
 586             if (zcl->data1_categoryList)
 587             {
 588                 assert (zcl->data1_categoryList->child);
 589                 node_cl = data1_search_tag (zei->dh,
 590                                             zcl->data1_categoryList->child,
 591                                             "categoryList");
 592                 assert (node_cl);
 593                 zebraExplain_initCommonInfo (zei, node_cl);
 594             }
 595         }
 596     }
 597     return zei;
 598 }
 599
 600 static void zebraExplain_readAttributeDetails (ZebraExplainInfo zei,
 601                                                zebAttributeDetails zad)
 602 {
 603     Record rec;
 604     struct zebSUInfoB **zsuip = &zad->SUInfo;
 605     data1_node *node_adinfo, *node_zebra, *node_list, *np;
 606
 607     assert (zad->sysno);
 608     rec = rec_get (zei->records, zad->sysno);
 609
 610     zad->data1_tree = read_sgml_rec (zei->dh, zei->nmem, rec);
 611
 612     node_adinfo = data1_search_tag (zei->dh, zad->data1_tree->child,
 613                                     "attributeDetails");
 614     node_zebra = data1_search_tag (zei->dh, node_adinfo->child,
 615                                  "zebraInfo");
 616     node_list = data1_search_tag (zei->dh, node_zebra->child,
 617                                   "attrlist");
 618     for (np = node_list->child; np; np = np->next)
 619     {
 620         data1_node *node_set = NULL;
 621         data1_node *node_use = NULL;
 622         data1_node *node_ordinal = NULL;
 623         data1_node *np2;
 624         char oid_str[128];
 625         int oid_str_len;
 626
 627         if (np->which != DATA1N_tag || strcmp (np->u.tag.tag, "attr"))
 628             continue;
 629         for (np2 = np->child; np2; np2 = np2->next)
 630         {
 631             if (np2->which != DATA1N_tag || !np2->child ||
 632                 np2->child->which != DATA1N_data)
 633                 continue;
 634             if (!strcmp (np2->u.tag.tag, "set"))
 635                 node_set = np2->child;
 636             else if (!strcmp (np2->u.tag.tag, "use"))
 637                 node_use = np2->child;
 638             else if (!strcmp (np2->u.tag.tag, "ordinal"))
 639                 node_ordinal = np2->child;
 640         }
 641         assert (node_set && node_use && node_ordinal);
 642
 643         oid_str_len = node_set->u.data.len;
 644         if (oid_str_len >= (int) sizeof(oid_str))
 645             oid_str_len = sizeof(oid_str)-1;
 646         memcpy (oid_str, node_set->u.data.data, oid_str_len);
 647         oid_str[oid_str_len] = '\0';
 648
 649         *zsuip = (struct zebSUInfoB *)
 650             nmem_malloc (zei->nmem, sizeof(**zsuip));
 651         (*zsuip)->info.set = oid_getvalbyname (oid_str);
 652
 653         (*zsuip)->info.use = atoi_n (node_use->u.data.data,
 654                                      node_use->u.data.len);
 655         (*zsuip)->info.ordinal = atoi_n (node_ordinal->u.data.data,
 656                                          node_ordinal->u.data.len);
 657         logf (LOG_DEBUG, "set=%d use=%d ordinal=%d",
 658               (*zsuip)->info.set, (*zsuip)->info.use, (*zsuip)->info.ordinal);
 659         zsuip = &(*zsuip)->next;
 660     }
 661     *zsuip = NULL;
 662     zad->readFlag = 0;
 663     rec_rm (&rec);
 664 }
 665
 666 static void zebraExplain_readDatabase (ZebraExplainInfo zei,
 667                                        struct zebDatabaseInfoB *zdi)
 668 {
 669     Record rec;
 670     data1_node *node_dbinfo, *node_zebra, *np;
 671
 672     assert (zdi->sysno);
 673     rec = rec_get (zei->records, zdi->sysno);
 674
 675     zdi->data1_database = read_sgml_rec (zei->dh, zei->nmem, rec);
 676
 677     node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database->child,
 678                                    "databaseInfo");
 679     zebraExplain_mergeAccessInfo (zei, node_dbinfo, &zdi->accessInfo);
 680
 681     node_zebra = data1_search_tag (zei->dh, node_dbinfo->child,
 682                                  "zebraInfo");
 683     if (node_zebra
 684         && (np = data1_search_tag (zei->dh, node_zebra->child,
 685                                    "recordBytes"))
 686         && np->child && np->child->which == DATA1N_data)
 687         zdi->recordBytes = atoi_n (np->child->u.data.data,
 688                                    np->child->u.data.len);
 689     if ((np = data1_search_tag (zei->dh, node_dbinfo->child,
 690                                 "recordCount")) &&
 691         (np = data1_search_tag (zei->dh, np->child,
 692                                 "recordCountActual")) &&
 693         np->child->which == DATA1N_data)
 694     {
 695         zdi->recordCount = atoi_n (np->child->u.data.data,
 696                                    np->child->u.data.len);
 697     }
 698     zdi->readFlag = 0;
 699     rec_rm (&rec);
 700 }
 701
 702 int zebraExplain_curDatabase (ZebraExplainInfo zei, const char *database)
 703 {
 704     struct zebDatabaseInfoB *zdi;
 705
 706     assert (zei);
 707     if (zei->curDatabaseInfo &&
 708         !strcmp (zei->curDatabaseInfo->databaseName, database))
 709         return 0;
 710     for (zdi = zei->databaseInfo; zdi; zdi=zdi->next)
 711     {
 712         if (!strcmp (zdi->databaseName, database))
 713             break;
 714     }
 715     if (!zdi)
 716         return -1;
 717 #if ZINFO_DEBUG
 718     logf (LOG_LOG, "zebraExplain_curDatabase: %s", database);
 719 #endif
 720     if (zdi->readFlag)
 721     {
 722 #if ZINFO_DEBUG
 723         logf (LOG_LOG, "zebraExplain_readDatabase: %s", database);
 724 #endif
 725         zebraExplain_readDatabase (zei, zdi);
 726     }
 727     if (zdi->attributeDetails->readFlag)
 728     {
 729 #if ZINFO_DEBUG
 730         logf (LOG_LOG, "zebraExplain_readAttributeDetails: %s", database);
 731 #endif
 732         zebraExplain_readAttributeDetails (zei, zdi->attributeDetails);
 733     }
 734     zei->curDatabaseInfo = zdi;
 735     return 0;
 736 }
 737
 738 static void zebraExplain_initCommonInfo (ZebraExplainInfo zei, data1_node *n)
 739 {
 740     data1_node *c = data1_add_tag (zei->dh, n, "commonInfo", zei->nmem);
 741
 742     data1_add_tagdata_text (zei->dh, c, "dateAdded", zei->date, zei->nmem);
 743     data1_add_tagdata_text (zei->dh, c, "dateChanged", zei->date, zei->nmem);
 744     data1_add_tagdata_text (zei->dh, c, "languageCode", "EN", zei->nmem);
 745 }
 746
 747 static void zebraExplain_updateCommonInfo (ZebraExplainInfo zei, data1_node *n)
 748 {
 749     data1_node *c = data1_search_tag (zei->dh, n->child, "commonInfo");
 750     assert (c);
 751     data1_make_tagdata_text (zei->dh, c, "dateChanged", zei->date, zei->nmem);
 752 }
 753
 754 static void zebraExplain_initAccessInfo (ZebraExplainInfo zei, data1_node *n)
 755 {
 756     data1_node *c = data1_add_tag (zei->dh, n, "accessInfo", zei->nmem);
 757     data1_node *d = data1_add_tag (zei->dh, c, "unitSystems", zei->nmem);
 758     data1_add_tagdata_text (zei->dh, d, "string", "ISO", zei->nmem);
 759 }
 760
 761 static void zebraExplain_updateAccessInfo (ZebraExplainInfo zei, data1_node *n,
 762                                            zebAccessInfo accessInfo)
 763 {
 764     data1_node *c = data1_search_tag (zei->dh, n->child, "accessInfo");
 765     data1_node *d;
 766     zebAccessObject p;
 767
 768     assert (c);
 769
 770     if ((p = accessInfo->attributeSetIds))
 771     {
 772         d = data1_make_tag (zei->dh, c, "attributeSetIds", zei->nmem);
 773         for (; p; p = p->next)
 774             data1_add_tagdata_oid (zei->dh, d, "oid", p->oid, zei->nmem);
 775     }
 776     if ((p = accessInfo->schemas))
 777     {
 778         d = data1_make_tag (zei->dh, c, "schemas", zei->nmem);
 779         for (; p; p = p->next)
 780             data1_add_tagdata_oid (zei->dh, d, "oid", p->oid, zei->nmem);
 781     }
 782 }
 783
 784 int zebraExplain_newDatabase (ZebraExplainInfo zei, const char *database,
 785                               int explain_database)
 786 {
 787     struct zebDatabaseInfoB *zdi;
 788     data1_node *node_dbinfo, *node_adinfo;
 789
 790 #if ZINFO_DEBUG
 791     logf (LOG_LOG, "zebraExplain_newDatabase: %s", database);
 792 #endif
 793     assert (zei);
 794     for (zdi = zei->databaseInfo; zdi; zdi=zdi->next)
 795     {
 796         if (!strcmp (zdi->databaseName, database))
 797             break;
 798     }
 799     if (zdi)
 800         return -1;
 801     /* it's new really. make it */
 802     zdi = (struct zebDatabaseInfoB *) nmem_malloc (zei->nmem, sizeof(*zdi));
 803     zdi->next = zei->databaseInfo;
 804     zei->databaseInfo = zdi;
 805     zdi->sysno = 0;
 806     zdi->recordCount = 0;
 807     zdi->recordBytes = 0;
 808     zdi->readFlag = 0;
 809     zdi->databaseName = nmem_strdup (zei->nmem, database);
 810
 811     zebraExplain_mergeAccessInfo (zei, 0, &zdi->accessInfo);
 812
 813     assert (zei->dh);
 814     assert (zei->nmem);
 815
 816     zdi->data1_database =
 817         data1_read_sgml (zei->dh, zei->nmem,
 818                          "<explain><databaseInfo>DatabaseInfo\n"
 819                          "</></>\n");
 820     if (!zdi->data1_database)
 821         return -2;
 822
 823     node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database->child,
 824                                    "databaseInfo");
 825     assert (node_dbinfo);
 826
 827     zebraExplain_initCommonInfo (zei, node_dbinfo);
 828     zebraExplain_initAccessInfo (zei, node_dbinfo);
 829
 830     data1_add_tagdata_text (zei->dh, node_dbinfo, "name",
 831                                database, zei->nmem);
 832
 833     if (explain_database)
 834         data1_add_tagdata_text (zei->dh, node_dbinfo, "explainDatabase",
 835                                 "", zei->nmem);
 836
 837     data1_add_tagdata_text (zei->dh, node_dbinfo, "userFee",
 838                             "0", zei->nmem);
 839
 840     data1_add_tagdata_text (zei->dh, node_dbinfo, "available",
 841                             "1", zei->nmem);
 842
 843 #if ZINFO_DEBUG
 844     data1_pr_tree (zei->dh, zdi->data1_database, stderr);
 845 #endif
 846     zdi->dirty = 1;
 847     zei->dirty = 1;
 848     zei->curDatabaseInfo = zdi;
 849
 850     zdi->attributeDetails = (zebAttributeDetails)
 851         nmem_malloc (zei->nmem, sizeof(*zdi->attributeDetails));
 852     zdi->attributeDetails->readFlag = 0;
 853     zdi->attributeDetails->sysno = 0;
 854     zdi->attributeDetails->dirty = 1;
 855     zdi->attributeDetails->SUInfo = NULL;
 856     zdi->attributeDetails->data1_tree =
 857         data1_read_sgml (zei->dh, zei->nmem,
 858                          "<explain><attributeDetails>AttributeDetails\n"
 859                          "</></>\n");
 860
 861     node_adinfo =
 862         data1_search_tag (zei->dh, zdi->attributeDetails->data1_tree->child,
 863                           "attributeDetails");
 864     assert (node_adinfo);
 865
 866     zebraExplain_initCommonInfo (zei, node_adinfo);
 867
 868     return 0;
 869 }
 870
 871 static void writeAttributeValueDetails (ZebraExplainInfo zei,
 872                                   zebAttributeDetails zad,
 873                                   data1_node *node_atvs, data1_attset *attset)
 874
 875 {
 876     struct zebSUInfoB *zsui;
 877     int set_ordinal = attset->reference;
 878     data1_attset_child *c;
 879
 880     for (c = attset->children; c; c = c->next)
 881         writeAttributeValueDetails (zei, zad, node_atvs, c->child);
 882     for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
 883     {
 884         data1_node *node_attvalue, *node_value;
 885         if (set_ordinal != zsui->info.set)
 886             continue;
 887         node_attvalue = data1_add_tag (zei->dh, node_atvs, "attributeValue",
 888                                        zei->nmem);
 889         node_value = data1_add_tag (zei->dh, node_attvalue, "value",
 890                                     zei->nmem);
 891         data1_add_tagdata_int (zei->dh, node_value, "numeric",
 892                                zsui->info.use, zei->nmem);
 893     }
 894 }
 895
 896 static void zebraExplain_writeCategoryList (ZebraExplainInfo zei,
 897                                             struct zebraCategoryListInfo *zcl,
 898                                             int key_flush)
 899 {
 900     char *sgml_buf;
 901     int sgml_len;
 902     int i;
 903     Record drec;
 904     data1_node *node_ci, *node_categoryList;
 905     int sysno = 0;
 906     static char *category[] = {
 907         "CategoryList",
 908         "TargetInfo",
 909         "DatabaseInfo",
 910         "AttributeDetails",
 911         NULL
 912     };
 913
 914     assert (zcl);
 915     if (!zcl->dirty)
 916         return ;
 917     zcl->dirty = 1;
 918     node_categoryList = zcl->data1_categoryList;
 919
 920 #if ZINFO_DEBUG
 921     logf (LOG_LOG, "zebraExplain_writeCategoryList");
 922 #endif
 923
 924     drec = createRecord (zei->records, &sysno);
 925
 926     node_ci = data1_search_tag (zei->dh, node_categoryList->child,
 927                                 "categoryList");
 928     assert (node_ci);
 929     node_ci = data1_add_tag (zei->dh, node_ci, "categories", zei->nmem);
 930     assert (node_ci);
 931
 932     for (i = 0; category[i]; i++)
 933     {
 934         data1_node *node_cat = data1_add_tag (zei->dh, node_ci,
 935                                               "category", zei->nmem);
 936
 937         data1_add_tagdata_text (zei->dh, node_cat, "name",
 938                                 category[i], zei->nmem);
 939     }
 940     /* extract *searchable* keys from it. We do this here, because
 941        record count, etc. is affected */
 942     if (key_flush)
 943         (*zei->updateFunc)(zei->updateHandle, drec, node_categoryList);
 944
 945     /* convert to "SGML" and write it */
 946 #if ZINFO_DEBUG
 947     data1_pr_tree (zei->dh, node_categoryList, stderr);
 948 #endif
 949     sgml_buf = data1_nodetoidsgml(zei->dh, node_categoryList, 0, &sgml_len);
 950     drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
 951     memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
 952     drec->size[recInfo_storeData] = sgml_len;
 953
 954     rec_put (zei->records, &drec);
 955 }
 956
 957 static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei,
 958                                                 zebAttributeDetails zad,
 959                                                 const char *databaseName,
 960                                                 int key_flush)
 961 {
 962     char *sgml_buf;
 963     int sgml_len;
 964     Record drec;
 965     data1_node *node_adinfo, *node_list, *node_zebra, *node_attributesBySet;
 966     struct zebSUInfoB *zsui;
 967     int set_min;
 968
 969     if (!zad->dirty)
 970         return;
 971
 972     zad->dirty = 0;
 973 #if ZINFO_DEBUG
 974     logf (LOG_LOG, "zebraExplain_writeAttributeDetails");
 975 #endif
 976
 977     drec = createRecord (zei->records, &zad->sysno);
 978     assert (zad->data1_tree);
 979     node_adinfo = data1_search_tag (zei->dh, zad->data1_tree->child,
 980                                    "attributeDetails");
 981     zebraExplain_updateCommonInfo (zei, node_adinfo);
 982
 983     data1_add_tagdata_text (zei->dh, node_adinfo, "name",
 984                             databaseName, zei->nmem);
 985
 986     /* extract *searchable* keys from it. We do this here, because
 987        record count, etc. is affected */
 988     if (key_flush)
 989         (*zei->updateFunc)(zei->updateHandle, drec, zad->data1_tree);
 990
 991     node_attributesBySet = data1_make_tag (zei->dh, node_adinfo,
 992                                            "attributesBySet", zei->nmem);
 993     set_min = -1;
 994     while (1)
 995     {
 996         data1_node *node_asd;
 997         data1_attset *attset;
 998         int set_ordinal = -1;
 999         for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
1000         {
1001             if ((set_ordinal < 0 || set_ordinal > zsui->info.set)
1002                 && zsui->info.set > set_min)
1003                 set_ordinal = zsui->info.set;
1004         }
1005         if (set_ordinal < 0)
1006             break;
1007         set_min = set_ordinal;
1008         node_asd = data1_add_tag (zei->dh, node_attributesBySet,
1009                                   "attributeSetDetails", zei->nmem);
1010
1011         attset = data1_attset_search_id (zei->dh, set_ordinal);
1012         if (!attset)
1013         {
1014             zebraExplain_loadAttsets (zei->dh, zei->res);
1015             attset = data1_attset_search_id (zei->dh, set_ordinal);
1016         }
1017         if (attset)
1018         {
1019             int oid[OID_SIZE];
1020             oident oe;
1021
1022             oe.proto = PROTO_Z3950;
1023             oe.oclass = CLASS_ATTSET;
1024             oe.value = (enum oid_value) set_ordinal;
1025
1026             if (oid_ent_to_oid (&oe, oid))
1027             {
1028                 data1_node *node_abt, *node_atd, *node_atvs;
1029                 data1_add_tagdata_oid (zei->dh, node_asd, "oid",
1030                                        oid, zei->nmem);
1031
1032                 node_abt = data1_add_tag (zei->dh, node_asd,
1033                                           "attributesByType", zei->nmem);
1034                 node_atd = data1_add_tag (zei->dh, node_abt,
1035                                           "attributeTypeDetails", zei->nmem);
1036                 data1_add_tagdata_int (zei->dh, node_atd,
1037                                        "type", 1, zei->nmem);
1038                 node_atvs = data1_add_tag (zei->dh, node_atd,
1039                                            "attributeValues", zei->nmem);
1040                 writeAttributeValueDetails (zei, zad, node_atvs, attset);
1041             }
1042         }
1043     }
1044     /* zebra info (private) */
1045     node_zebra = data1_make_tag (zei->dh, node_adinfo,
1046                                  "zebraInfo", zei->nmem);
1047     node_list = data1_make_tag (zei->dh, node_zebra,
1048                                  "attrlist", zei->nmem);
1049     for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
1050     {
1051         struct oident oident;
1052         int oid[OID_SIZE];
1053         data1_node *node_attr;
1054
1055         node_attr = data1_add_tag (zei->dh, node_list, "attr", zei->nmem);
1056
1057         oident.proto = PROTO_Z3950;
1058         oident.oclass = CLASS_ATTSET;
1059         oident.value = (enum oid_value) zsui->info.set;
1060         oid_ent_to_oid (&oident, oid);
1061
1062         data1_add_tagdata_text (zei->dh, node_attr, "set",
1063                                 oident.desc, zei->nmem);
1064         data1_add_tagdata_int (zei->dh, node_attr, "use",
1065                                zsui->info.use, zei->nmem);
1066         data1_add_tagdata_int (zei->dh, node_attr, "ordinal",
1067                                zsui->info.ordinal, zei->nmem);
1068     }
1069     /* convert to "SGML" and write it */
1070 #if ZINFO_DEBUG
1071     data1_pr_tree (zei->dh, zad->data1_tree, stderr);
1072 #endif
1073     sgml_buf = data1_nodetoidsgml(zei->dh, zad->data1_tree,
1074                                   0, &sgml_len);
1075     drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
1076     memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
1077     drec->size[recInfo_storeData] = sgml_len;
1078
1079     rec_put (zei->records, &drec);
1080 }
1081
1082 static void zebraExplain_writeDatabase (ZebraExplainInfo zei,
1083                                         struct zebDatabaseInfoB *zdi,
1084                                         int key_flush)
1085 {
1086     char *sgml_buf;
1087     int sgml_len;
1088     Record drec;
1089     data1_node *node_dbinfo, *node_count, *node_zebra;
1090
1091     if (!zdi->dirty)
1092         return;
1093
1094     zdi->dirty = 0;
1095 #if ZINFO_DEBUG
1096     logf (LOG_LOG, "zebraExplain_writeDatabase %s", zdi->databaseName);
1097 #endif
1098     drec = createRecord (zei->records, &zdi->sysno);
1099     assert (zdi->data1_database);
1100     node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database->child,
1101                                    "databaseInfo");
1102
1103     zebraExplain_updateCommonInfo (zei, node_dbinfo);
1104     zebraExplain_updateAccessInfo (zei, node_dbinfo, zdi->accessInfo);
1105
1106     /* extract *searchable* keys from it. We do this here, because
1107        record count, etc. is affected */
1108     if (key_flush)
1109         (*zei->updateFunc)(zei->updateHandle, drec, zdi->data1_database);
1110     /* record count */
1111     node_count = data1_make_tag (zei->dh, node_dbinfo,
1112                                  "recordCount", zei->nmem);
1113     data1_add_tagdata_int (zei->dh, node_count, "recordCountActual",
1114                               zdi->recordCount, zei->nmem);
1115
1116     /* zebra info (private) */
1117     node_zebra = data1_make_tag (zei->dh, node_dbinfo,
1118                                  "zebraInfo", zei->nmem);
1119     data1_add_tagdata_int (zei->dh, node_zebra,
1120                            "recordBytes", zdi->recordBytes, zei->nmem);
1121     /* convert to "SGML" and write it */
1122 #if ZINFO_DEBUG
1123     data1_pr_tree (zei->dh, zdi->data1_database, stderr);
1124 #endif
1125     sgml_buf = data1_nodetoidsgml(zei->dh, zdi->data1_database,
1126                                   0, &sgml_len);
1127     drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
1128     memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
1129     drec->size[recInfo_storeData] = sgml_len;
1130
1131     rec_put (zei->records, &drec);
1132 }
1133
1134 static void writeAttributeValues (ZebraExplainInfo zei,
1135                                   data1_node *node_values,
1136                                   data1_attset *attset)
1137 {
1138     data1_att *atts;
1139     data1_attset_child *c;
1140
1141     if (!attset)
1142         return;
1143
1144     for (c = attset->children; c; c = c->next)
1145         writeAttributeValues (zei, node_values, c->child);
1146     for (atts = attset->atts; atts; atts = atts->next)
1147     {
1148         data1_node *node_value;
1149
1150         node_value = data1_add_tag (zei->dh, node_values, "attributeValue",
1151                                     zei->nmem);
1152         data1_add_tagdata_text (zei->dh, node_value, "name",
1153                                 atts->name, zei->nmem);
1154         node_value = data1_add_tag (zei->dh, node_value, "value", zei->nmem);
1155         data1_add_tagdata_int (zei->dh, node_value, "numeric",
1156                                atts->value, zei->nmem);
1157     }
1158 }
1159
1160
1161 static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei,
1162                                             zebAccessObject o,
1163                                             int key_flush)
1164 {
1165     char *sgml_buf;
1166     int sgml_len;
1167     Record drec;
1168     data1_node *node_root, *node_attinfo, *node_attributes, *node_atttype;
1169     data1_node *node_values;
1170     struct oident *entp;
1171     struct data1_attset *attset = NULL;
1172
1173     if ((entp = oid_getentbyoid (o->oid)))
1174         attset = data1_attset_search_id (zei->dh, entp->value);
1175
1176 #if ZINFO_DEBUG
1177     logf (LOG_LOG, "zebraExplain_writeAttributeSet %s",
1178           attset ? attset->name : "<unknown>");
1179 #endif
1180
1181     drec = createRecord (zei->records, &o->sysno);
1182     node_root =
1183         data1_read_sgml (zei->dh, zei->nmem,
1184                          "<explain><attributeSetInfo>AttributeSetInfo\n"
1185                          "</></>\n" );
1186
1187     node_attinfo = data1_search_tag (zei->dh, node_root->child,
1188                                    "attributeSetInfo");
1189
1190     zebraExplain_initCommonInfo (zei, node_attinfo);
1191     zebraExplain_updateCommonInfo (zei, node_attinfo);
1192
1193     data1_add_tagdata_oid (zei->dh, node_attinfo,
1194                             "oid", o->oid, zei->nmem);
1195     if (attset && attset->name)
1196         data1_add_tagdata_text (zei->dh, node_attinfo,
1197                                 "name", attset->name, zei->nmem);
1198
1199     node_attributes = data1_make_tag (zei->dh, node_attinfo,
1200                                       "attributes", zei->nmem);
1201     node_atttype = data1_make_tag (zei->dh, node_attributes,
1202                                    "attributeType", zei->nmem);
1203     data1_add_tagdata_text (zei->dh, node_atttype,
1204                             "name", "Use", zei->nmem);
1205     data1_add_tagdata_text (zei->dh, node_atttype,
1206                             "description", "Use Attribute", zei->nmem);
1207     data1_add_tagdata_int (zei->dh, node_atttype,
1208                            "type", 1, zei->nmem);
1209     node_values = data1_add_tag (zei->dh, node_atttype,
1210                                  "attributeValues", zei->nmem);
1211     if (attset)
1212         writeAttributeValues (zei, node_values, attset);
1213
1214     /* extract *searchable* keys from it. We do this here, because
1215        record count, etc. is affected */
1216     if (key_flush)
1217         (*zei->updateFunc)(zei->updateHandle, drec, node_root);
1218     /* convert to "SGML" and write it */
1219 #if ZINFO_DEBUG
1220     data1_pr_tree (zei->dh, node_root, stderr);
1221 #endif
1222     sgml_buf = data1_nodetoidsgml(zei->dh, node_root, 0, &sgml_len);
1223     drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
1224     memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
1225     drec->size[recInfo_storeData] = sgml_len;
1226
1227     rec_put (zei->records, &drec);
1228 }
1229
1230 static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush)
1231 {
1232     struct zebDatabaseInfoB *zdi;
1233     data1_node *node_tgtinfo, *node_list, *node_zebra;
1234     Record trec;
1235     int sgml_len;
1236     char *sgml_buf;
1237
1238     if (!zei->dirty)
1239         return;
1240     zei->dirty = 0;
1241
1242     trec = rec_get (zei->records, 1);
1243     xfree (trec->info[recInfo_storeData]);
1244
1245     node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target->child,
1246                                    "targetInfo");
1247     assert (node_tgtinfo);
1248
1249     zebraExplain_updateCommonInfo (zei, node_tgtinfo);
1250     zebraExplain_updateAccessInfo (zei, node_tgtinfo, zei->accessInfo);
1251
1252     /* convert to "SGML" and write it */
1253     if (key_flush)
1254         (*zei->updateFunc)(zei->updateHandle, trec, zei->data1_target);
1255
1256     node_zebra = data1_make_tag (zei->dh, node_tgtinfo,
1257                                  "zebraInfo", zei->nmem);
1258     data1_add_tagdata_text (zei->dh, node_zebra, "version",
1259                                ZEBRAVER, zei->nmem);
1260     node_list = data1_add_tag (zei->dh, node_zebra,
1261                                   "databaseList", zei->nmem);
1262     for (zdi = zei->databaseInfo; zdi; zdi = zdi->next)
1263     {
1264         data1_node *node_db;
1265         node_db = data1_add_tag (zei->dh, node_list,
1266                                     "database", zei->nmem);
1267         data1_add_tagdata_text (zei->dh, node_db, "name",
1268                                    zdi->databaseName, zei->nmem);
1269         data1_add_tagdata_int (zei->dh, node_db, "id",
1270                                   zdi->sysno, zei->nmem);
1271         data1_add_tagdata_int (zei->dh, node_db, "attributeDetailsId",
1272                                   zdi->attributeDetails->sysno, zei->nmem);
1273     }
1274     data1_add_tagdata_int (zei->dh, node_zebra, "ordinalSU",
1275                               zei->ordinalSU, zei->nmem);
1276
1277     data1_add_tagdata_int (zei->dh, node_zebra, "runNumber",
1278                               zei->runNumber, zei->nmem);
1279
1280 #if ZINFO_DEBUG
1281     data1_pr_tree (zei->dh, zei->data1_target, stderr);
1282 #endif
1283     sgml_buf = data1_nodetoidsgml(zei->dh, zei->data1_target,
1284                                   0, &sgml_len);
1285     trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
1286     memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len);
1287     trec->size[recInfo_storeData] = sgml_len;
1288
1289     rec_put (zei->records, &trec);
1290 }
1291
1292 int zebraExplain_lookupSU (ZebraExplainInfo zei, int set, int use)
1293 {
1294     struct zebSUInfoB *zsui;
1295
1296     assert (zei->curDatabaseInfo);
1297     for (zsui = zei->curDatabaseInfo->attributeDetails->SUInfo;
1298          zsui; zsui=zsui->next)
1299         if (zsui->info.use == use && zsui->info.set == set)
1300             return zsui->info.ordinal;
1301     return -1;
1302 }
1303
1304 int zebraExplain_lookup_ord (ZebraExplainInfo zei, int ord,
1305                              const char **db, int *set, int *use)
1306 {
1307     struct zebDatabaseInfoB *zdb;
1308     for (zdb = zei->databaseInfo; zdb; zdb = zdb->next)
1309     {
1310         struct zebSUInfoB *zsui = zdb->attributeDetails->SUInfo;
1311         for ( ;zsui; zsui = zsui->next)
1312             if (zsui->info.ordinal == ord)
1313             {
1314                 *db = zdb->databaseName;
1315                 *set = zsui->info.set;
1316                 *use = zsui->info.use;
1317                 return 0;
1318             }
1319     }
1320     return -1;
1321 }
1322
1323 zebAccessObject zebraExplain_announceOid (ZebraExplainInfo zei,
1324                                           zebAccessObject *op,
1325                                           Odr_oid *oid)
1326 {
1327     zebAccessObject ao;
1328
1329     for (ao = *op; ao; ao = ao->next)
1330         if (!oid_oidcmp (oid, ao->oid))
1331             break;
1332     if (!ao)
1333     {
1334         ao = (zebAccessObject) nmem_malloc (zei->nmem, sizeof(*ao));
1335         ao->handle = NULL;
1336         ao->sysno = 0;
1337         ao->oid = odr_oiddup_nmem (zei->nmem, oid);
1338         ao->next = *op;
1339         *op = ao;
1340     }
1341     return ao;
1342 }
1343
1344 void zebraExplain_addAttributeSet (ZebraExplainInfo zei, int set)
1345 {
1346     oident oe;
1347     int oid[OID_SIZE];
1348
1349     oe.proto = PROTO_Z3950;
1350     oe.oclass = CLASS_ATTSET;
1351     oe.value = (enum oid_value) set;
1352
1353     if (oid_ent_to_oid (&oe, oid))
1354     {
1355         zebraExplain_announceOid (zei, &zei->accessInfo->attributeSetIds, oid);
1356         zebraExplain_announceOid (zei, &zei->curDatabaseInfo->
1357                                   accessInfo->attributeSetIds, oid);
1358     }
1359 }
1360
1361 int zebraExplain_addSU (ZebraExplainInfo zei, int set, int use)
1362 {
1363     struct zebSUInfoB *zsui;
1364
1365     assert (zei->curDatabaseInfo);
1366     for (zsui = zei->curDatabaseInfo->attributeDetails->SUInfo;
1367          zsui; zsui=zsui->next)
1368         if (zsui->info.use == use && zsui->info.set == set)
1369             return -1;
1370     zebraExplain_addAttributeSet (zei, set);
1371     zsui = (struct zebSUInfoB *) nmem_malloc (zei->nmem, sizeof(*zsui));
1372     zsui->next = zei->curDatabaseInfo->attributeDetails->SUInfo;
1373     zei->curDatabaseInfo->attributeDetails->SUInfo = zsui;
1374     zei->curDatabaseInfo->attributeDetails->dirty = 1;
1375     zei->dirty = 1;
1376     zsui->info.set = set;
1377     zsui->info.use = use;
1378     zsui->info.ordinal = (zei->ordinalSU)++;
1379     return zsui->info.ordinal;
1380 }
1381
1382 void zebraExplain_addSchema (ZebraExplainInfo zei, Odr_oid *oid)
1383 {
1384     zebraExplain_announceOid (zei, &zei->accessInfo->schemas, oid);
1385     zebraExplain_announceOid (zei, &zei->curDatabaseInfo->
1386                               accessInfo->schemas, oid);
1387 }
1388
1389 void zebraExplain_recordBytesIncrement (ZebraExplainInfo zei, int adjust_num)
1390 {
1391     assert (zei->curDatabaseInfo);
1392
1393     if (adjust_num)
1394     {
1395         zei->curDatabaseInfo->recordBytes += adjust_num;
1396         zei->curDatabaseInfo->dirty = 1;
1397     }
1398 }
1399
1400 void zebraExplain_recordCountIncrement (ZebraExplainInfo zei, int adjust_num)
1401 {
1402     assert (zei->curDatabaseInfo);
1403
1404     if (adjust_num)
1405     {
1406         zei->curDatabaseInfo->recordCount += adjust_num;
1407         zei->curDatabaseInfo->dirty = 1;
1408     }
1409 }
1410
1411 int zebraExplain_runNumberIncrement (ZebraExplainInfo zei, int adjust_num)
1412 {
1413     if (adjust_num)
1414         zei->dirty = 1;
1415     return zei->runNumber += adjust_num;
1416 }
1417
1418 RecordAttr *rec_init_attr (ZebraExplainInfo zei, Record rec)
1419 {
1420     RecordAttr *recordAttr;
1421
1422     if (rec->info[recInfo_attr])
1423         return (RecordAttr *) rec->info[recInfo_attr];
1424     recordAttr = (RecordAttr *) xmalloc (sizeof(*recordAttr));
1425     rec->info[recInfo_attr] = (char *) recordAttr;
1426     rec->size[recInfo_attr] = sizeof(*recordAttr);
1427
1428     recordAttr->recordSize = 0;
1429     recordAttr->recordOffset = 0;
1430     recordAttr->runNumber = zei->runNumber;
1431     return recordAttr;
1432 }
1433
1434 static void att_loadset(void *p, const char *n, const char *name)
1435 {
1436     data1_handle dh = (data1_handle) p;
1437     if (!data1_get_attset (dh, name))
1438         logf (LOG_WARN, "Couldn't load attribute set %s", name);
1439 }
1440
1441 void zebraExplain_loadAttsets (data1_handle dh, Res res)
1442 {
1443     res_trav(res, "attset", dh, att_loadset);
1444 }
1445
1446 /*
1447      zebraExplain_addSU adds to AttributeDetails for a database and
1448      adds attributeSet (in AccessInfo area) to DatabaseInfo if it doesn't
1449      exist for the database.
1450
1451      If the database doesn't exist globally (in TargetInfo) an
1452      AttributeSetInfo must be added (globally).
1453  */