+static void writeAttributeValueDetails (ZebraExplainInfo zei,
+ zebAttributeDetails zad,
+ data1_node *node_atvs, data1_attset *attset)
+
+{
+ struct zebSUInfoB *zsui;
+ int set_ordinal = attset->reference;
+ data1_attset_child *c;
+
+ for (c = attset->children; c; c = c->next)
+ writeAttributeValueDetails (zei, zad, node_atvs, c->child);
+ for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
+ {
+ data1_node *node_attvalue, *node_value;
+ if (set_ordinal != zsui->info.set)
+ continue;
+ node_attvalue = data1_add_tag (zei->dh, node_atvs, "attributeValue",
+ zei->nmem);
+ node_value = data1_add_tag (zei->dh, node_attvalue, "value",
+ zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_value, "numeric",
+ zsui->info.use, zei->nmem);
+ }
+}
+
+static void zebraExplain_writeCategoryList (ZebraExplainInfo zei,
+ struct zebraCategoryListInfo *zcl,
+ int key_flush)
+{
+ char *sgml_buf;
+ int sgml_len;
+ int i;
+ Record drec;
+ data1_node *node_ci, *node_categoryList;
+ int sysno = 0;
+ static char *category[] = {
+ "CategoryList",
+ "TargetInfo",
+ "DatabaseInfo",
+ "AttributeDetails",
+ NULL
+ };
+
+ assert (zcl);
+ if (!zcl->dirty)
+ return ;
+ zcl->dirty = 1;
+ node_categoryList = zcl->data1_categoryList;
+
+#if ZINFO_DEBUG
+ logf (LOG_LOG, "zebraExplain_writeCategoryList");
+#endif
+
+ drec = createRecord (zei->records, &sysno);
+
+ node_ci = data1_search_tag (zei->dh, node_categoryList->child,
+ "categoryList");
+ assert (node_ci);
+ node_ci = data1_add_tag (zei->dh, node_ci, "categories", zei->nmem);
+ assert (node_ci);
+
+ for (i = 0; category[i]; i++)
+ {
+ data1_node *node_cat = data1_add_tag (zei->dh, node_ci,
+ "category", zei->nmem);
+
+ data1_add_tagdata_text (zei->dh, node_cat, "name",
+ category[i], zei->nmem);
+ }
+ /* extract *searchable* keys from it. We do this here, because
+ record count, etc. is affected */
+ if (key_flush)
+ (*zei->updateFunc)(zei->updateHandle, drec, node_categoryList);
+
+ /* convert to "SGML" and write it */
+#if ZINFO_DEBUG
+ data1_pr_tree (zei->dh, node_categoryList, stderr);
+#endif
+ sgml_buf = data1_nodetoidsgml(zei->dh, node_categoryList, 0, &sgml_len);
+ drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
+ memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
+ drec->size[recInfo_storeData] = sgml_len;
+
+ rec_put (zei->records, &drec);
+}
+
+static void zebraExplain_writeAttributeDetails (ZebraExplainInfo zei,
+ zebAttributeDetails zad,
+ const char *databaseName,
+ int key_flush)
+{
+ char *sgml_buf;
+ int sgml_len;
+ Record drec;
+ data1_node *node_adinfo, *node_list, *node_zebra, *node_attributesBySet;
+ struct zebSUInfoB *zsui;
+ int set_min;
+
+ if (!zad->dirty)
+ return;
+
+ zad->dirty = 0;
+#if ZINFO_DEBUG
+ logf (LOG_LOG, "zebraExplain_writeAttributeDetails");
+#endif
+
+ drec = createRecord (zei->records, &zad->sysno);
+ assert (zad->data1_tree);
+ node_adinfo = data1_search_tag (zei->dh, zad->data1_tree->child,
+ "attributeDetails");
+ zebraExplain_updateCommonInfo (zei, node_adinfo);
+
+ data1_add_tagdata_text (zei->dh, node_adinfo, "name",
+ databaseName, zei->nmem);
+
+ /* extract *searchable* keys from it. We do this here, because
+ record count, etc. is affected */
+ if (key_flush)
+ (*zei->updateFunc)(zei->updateHandle, drec, zad->data1_tree);
+
+ node_attributesBySet = data1_make_tag (zei->dh, node_adinfo,
+ "attributesBySet", zei->nmem);
+ set_min = -1;
+ while (1)
+ {
+ data1_node *node_asd;
+ data1_attset *attset;
+ int set_ordinal = -1;
+ for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
+ {
+ if ((set_ordinal < 0 || set_ordinal > zsui->info.set)
+ && zsui->info.set > set_min)
+ set_ordinal = zsui->info.set;
+ }
+ if (set_ordinal < 0)
+ break;
+ set_min = set_ordinal;
+ node_asd = data1_add_tag (zei->dh, node_attributesBySet,
+ "attributeSetDetails", zei->nmem);
+
+ attset = data1_attset_search_id (zei->dh, set_ordinal);
+ if (!attset)
+ {
+ zebraExplain_loadAttsets (zei->dh, zei->res);
+ attset = data1_attset_search_id (zei->dh, set_ordinal);
+ }
+ if (attset)
+ {
+ int oid[OID_SIZE];
+ oident oe;
+
+ oe.proto = PROTO_Z3950;
+ oe.oclass = CLASS_ATTSET;
+ oe.value = (enum oid_value) set_ordinal;
+
+ if (oid_ent_to_oid (&oe, oid))
+ {
+ data1_node *node_abt, *node_atd, *node_atvs;
+ data1_add_tagdata_oid (zei->dh, node_asd, "oid",
+ oid, zei->nmem);
+
+ node_abt = data1_add_tag (zei->dh, node_asd,
+ "attributesByType", zei->nmem);
+ node_atd = data1_add_tag (zei->dh, node_abt,
+ "attributeTypeDetails", zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_atd,
+ "type", 1, zei->nmem);
+ node_atvs = data1_add_tag (zei->dh, node_atd,
+ "attributeValues", zei->nmem);
+ writeAttributeValueDetails (zei, zad, node_atvs, attset);
+ }
+ }
+ }
+ /* zebra info (private) */
+ node_zebra = data1_make_tag (zei->dh, node_adinfo,
+ "zebraInfo", zei->nmem);
+ node_list = data1_make_tag (zei->dh, node_zebra,
+ "attrlist", zei->nmem);
+ for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
+ {
+ struct oident oident;
+ int oid[OID_SIZE];
+ data1_node *node_attr;
+
+ node_attr = data1_add_tag (zei->dh, node_list, "attr", zei->nmem);
+
+ oident.proto = PROTO_Z3950;
+ oident.oclass = CLASS_ATTSET;
+ oident.value = (enum oid_value) zsui->info.set;
+ oid_ent_to_oid (&oident, oid);
+
+ data1_add_tagdata_text (zei->dh, node_attr, "set",
+ oident.desc, zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_attr, "use",
+ zsui->info.use, zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_attr, "ordinal",
+ zsui->info.ordinal, zei->nmem);
+ }
+ /* convert to "SGML" and write it */
+#if ZINFO_DEBUG
+ data1_pr_tree (zei->dh, zad->data1_tree, stderr);
+#endif
+ sgml_buf = data1_nodetoidsgml(zei->dh, zad->data1_tree,
+ 0, &sgml_len);
+ drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
+ memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
+ drec->size[recInfo_storeData] = sgml_len;
+
+ rec_put (zei->records, &drec);
+}
+
+static void zebraExplain_writeDatabase (ZebraExplainInfo zei,
+ struct zebDatabaseInfoB *zdi,
+ int key_flush)
+{
+ char *sgml_buf;
+ int sgml_len;
+ Record drec;
+ data1_node *node_dbinfo, *node_count, *node_zebra;
+
+ if (!zdi->dirty)
+ return;
+
+ zdi->dirty = 0;
+#if ZINFO_DEBUG
+ logf (LOG_LOG, "zebraExplain_writeDatabase %s", zdi->databaseName);
+#endif
+ drec = createRecord (zei->records, &zdi->sysno);
+ assert (zdi->data1_database);
+ node_dbinfo = data1_search_tag (zei->dh, zdi->data1_database->child,
+ "databaseInfo");
+
+ zebraExplain_updateCommonInfo (zei, node_dbinfo);
+ zebraExplain_updateAccessInfo (zei, node_dbinfo, zdi->accessInfo);
+
+ /* extract *searchable* keys from it. We do this here, because
+ record count, etc. is affected */
+ if (key_flush)
+ (*zei->updateFunc)(zei->updateHandle, drec, zdi->data1_database);
+ /* record count */
+ node_count = data1_make_tag (zei->dh, node_dbinfo,
+ "recordCount", zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_count, "recordCountActual",
+ zdi->recordCount, zei->nmem);
+
+ /* zebra info (private) */
+ node_zebra = data1_make_tag (zei->dh, node_dbinfo,
+ "zebraInfo", zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_zebra,
+ "recordBytes", zdi->recordBytes, zei->nmem);
+ /* convert to "SGML" and write it */
+#if ZINFO_DEBUG
+ data1_pr_tree (zei->dh, zdi->data1_database, stderr);
+#endif
+ sgml_buf = data1_nodetoidsgml(zei->dh, zdi->data1_database,
+ 0, &sgml_len);
+ drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
+ memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
+ drec->size[recInfo_storeData] = sgml_len;
+
+ rec_put (zei->records, &drec);
+}
+
+static void writeAttributeValues (ZebraExplainInfo zei,
+ data1_node *node_values,
+ data1_attset *attset)
+{
+ data1_att *atts;
+ data1_attset_child *c;
+
+ if (!attset)
+ return;
+
+ for (c = attset->children; c; c = c->next)
+ writeAttributeValues (zei, node_values, c->child);
+ for (atts = attset->atts; atts; atts = atts->next)
+ {
+ data1_node *node_value;
+
+ node_value = data1_add_tag (zei->dh, node_values, "attributeValue",
+ zei->nmem);
+ data1_add_tagdata_text (zei->dh, node_value, "name",
+ atts->name, zei->nmem);
+ node_value = data1_add_tag (zei->dh, node_value, "value", zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_value, "numeric",
+ atts->value, zei->nmem);
+ }
+}
+
+
+static void zebraExplain_writeAttributeSet (ZebraExplainInfo zei,
+ zebAccessObject o,
+ int key_flush)
+{
+ char *sgml_buf;
+ int sgml_len;
+ Record drec;
+ data1_node *node_root, *node_attinfo, *node_attributes, *node_atttype;
+ data1_node *node_values;
+ struct oident *entp;
+ struct data1_attset *attset = NULL;
+
+ if ((entp = oid_getentbyoid (o->oid)))
+ attset = data1_attset_search_id (zei->dh, entp->value);
+
+#if ZINFO_DEBUG
+ logf (LOG_LOG, "zebraExplain_writeAttributeSet %s",
+ attset ? attset->name : "<unknown>");
+#endif
+
+ drec = createRecord (zei->records, &o->sysno);
+ node_root =
+ data1_read_sgml (zei->dh, zei->nmem,
+ "<explain><attributeSetInfo>AttributeSetInfo\n"
+ "</></>\n" );
+
+ node_attinfo = data1_search_tag (zei->dh, node_root->child,
+ "attributeSetInfo");
+
+ zebraExplain_initCommonInfo (zei, node_attinfo);
+ zebraExplain_updateCommonInfo (zei, node_attinfo);
+
+ data1_add_tagdata_oid (zei->dh, node_attinfo,
+ "oid", o->oid, zei->nmem);
+ if (attset && attset->name)
+ data1_add_tagdata_text (zei->dh, node_attinfo,
+ "name", attset->name, zei->nmem);
+
+ node_attributes = data1_make_tag (zei->dh, node_attinfo,
+ "attributes", zei->nmem);
+ node_atttype = data1_make_tag (zei->dh, node_attributes,
+ "attributeType", zei->nmem);
+ data1_add_tagdata_text (zei->dh, node_atttype,
+ "name", "Use", zei->nmem);
+ data1_add_tagdata_text (zei->dh, node_atttype,
+ "description", "Use Attribute", zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_atttype,
+ "type", 1, zei->nmem);
+ node_values = data1_add_tag (zei->dh, node_atttype,
+ "attributeValues", zei->nmem);
+ if (attset)
+ writeAttributeValues (zei, node_values, attset);
+
+ /* extract *searchable* keys from it. We do this here, because
+ record count, etc. is affected */
+ if (key_flush)
+ (*zei->updateFunc)(zei->updateHandle, drec, node_root);
+ /* convert to "SGML" and write it */
+#if ZINFO_DEBUG
+ data1_pr_tree (zei->dh, node_root, stderr);
+#endif
+ sgml_buf = data1_nodetoidsgml(zei->dh, node_root, 0, &sgml_len);
+ drec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
+ memcpy (drec->info[recInfo_storeData], sgml_buf, sgml_len);
+ drec->size[recInfo_storeData] = sgml_len;
+
+ rec_put (zei->records, &drec);
+}
+
+static void zebraExplain_writeTarget (ZebraExplainInfo zei, int key_flush)
+{
+ struct zebDatabaseInfoB *zdi;
+ data1_node *node_tgtinfo, *node_list, *node_zebra;
+ Record trec;
+ int sgml_len;
+ char *sgml_buf;
+
+ if (!zei->dirty)
+ return;
+ zei->dirty = 0;
+
+ trec = rec_get (zei->records, 1);
+ xfree (trec->info[recInfo_storeData]);
+
+ node_tgtinfo = data1_search_tag (zei->dh, zei->data1_target->child,
+ "targetInfo");
+ assert (node_tgtinfo);
+
+ zebraExplain_updateCommonInfo (zei, node_tgtinfo);
+ zebraExplain_updateAccessInfo (zei, node_tgtinfo, zei->accessInfo);
+
+ /* convert to "SGML" and write it */
+ if (key_flush)
+ (*zei->updateFunc)(zei->updateHandle, trec, zei->data1_target);
+
+ node_zebra = data1_make_tag (zei->dh, node_tgtinfo,
+ "zebraInfo", zei->nmem);
+ data1_add_tagdata_text (zei->dh, node_zebra, "version",
+ ZEBRAVER, zei->nmem);
+ node_list = data1_add_tag (zei->dh, node_zebra,
+ "databaseList", zei->nmem);
+ for (zdi = zei->databaseInfo; zdi; zdi = zdi->next)
+ {
+ data1_node *node_db;
+ node_db = data1_add_tag (zei->dh, node_list,
+ "database", zei->nmem);
+ data1_add_tagdata_text (zei->dh, node_db, "name",
+ zdi->databaseName, zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_db, "id",
+ zdi->sysno, zei->nmem);
+ data1_add_tagdata_int (zei->dh, node_db, "attributeDetailsId",
+ zdi->attributeDetails->sysno, zei->nmem);
+ }
+ data1_add_tagdata_int (zei->dh, node_zebra, "ordinalSU",
+ zei->ordinalSU, zei->nmem);
+
+ data1_add_tagdata_int (zei->dh, node_zebra, "runNumber",
+ zei->runNumber, zei->nmem);
+
+#if ZINFO_DEBUG
+ data1_pr_tree (zei->dh, zei->data1_target, stderr);
+#endif
+ sgml_buf = data1_nodetoidsgml(zei->dh, zei->data1_target,
+ 0, &sgml_len);
+ trec->info[recInfo_storeData] = (char *) xmalloc (sgml_len);
+ memcpy (trec->info[recInfo_storeData], sgml_buf, sgml_len);
+ trec->size[recInfo_storeData] = sgml_len;
+
+ rec_put (zei->records, &trec);
+}
+
+int zebraExplain_lookupSU (ZebraExplainInfo zei, int set, int use)