-/* $Id: zinfo.c,v 1.79 2007-10-29 11:10:43 adam Exp $
- Copyright (C) 1995-2007
- Index Data ApS
-
-This file is part of the Zebra server.
+/* This file is part of the Zebra server.
+ Copyright (C) Index Data
Zebra is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
*/
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <sys/types.h>
#include <assert.h>
#include <stdlib.h>
#define ZINFO_DEBUG 0
struct zebSUInfo {
- int index_type;
+ char *index_type;
zinfo_index_category_t cat;
-#define ZEB_SU_SET_USE 1
-#define ZEB_SU_STR 2
- int which;
- union {
- char *str;
- } u;
+ char *str;
int ordinal;
zint doc_occurrences;
zint term_occurrences;
if (!rec)
return 0;
*sysno = rec->sysno;
-
+
rec->info[recInfo_fileType] =
rec_strdup("grs.sgml", &rec->size[recInfo_fileType]);
rec->info[recInfo_databaseName] =
rec_strdup("IR-Explain-1",
- &rec->size[recInfo_databaseName]);
+ &rec->size[recInfo_databaseName]);
}
return rec;
}
len = 63;
memcpy(str, np->child->u.data.data, len);
str[len] = '\0';
-
+
oid = odr_getoidbystr_nmem(zei->nmem, str);
for (ao = *op; ao; ao = ao->next)
zebAccessInfo *accessInfo)
{
data1_node *np;
-
+
if (!n)
{
*accessInfo = (zebAccessInfo)
zei->records = records;
zei->nmem = nmem;
zei->dh = dh;
-
+
data1_get_absyn(zei->dh, "explain", DATA1_XPATH_INDEXING_DISABLE);
zei->attsets = 0;
node_aid = np2->child;
}
assert(node_id && node_name && node_aid);
-
- *zdip =(struct zebDatabaseInfoB *)
+
+ *zdip =(struct zebDatabaseInfoB *)
nmem_malloc(zei->nmem, sizeof(**zdip));
(*zdip)->readFlag = 1;
(*zdip)->dirty = 0;
np = np->child;
assert(np && np->which == DATA1N_data);
zei->ordinalSU = atoi_n(np->u.data.data, np->u.data.len);
-
+
np = data1_search_tag(zei->dh, node_zebra->child,
"ordinalDatabase");
np = np->child;
rec_strdup("grs.sgml", &trec->size[recInfo_fileType]);
trec->info[recInfo_databaseName] =
rec_strdup("IR-Explain-1", &trec->size[recInfo_databaseName]);
-
+
sgml_buf = data1_nodetoidsgml(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(records, &trec);
rec_free(&trec);
}
-
+
zebraExplain_newDatabase(zei, "IR-Explain-1", 0);
-
+
if (!zei->categoryList->dirty)
{
struct zebraCategoryListInfo *zcl = zei->categoryList;
data1_node *node_cl;
-
+
zcl->dirty = 1;
zcl->data1_categoryList =
data1_read_sgml(zei->dh, zei->nmem,
"<explain><categoryList>CategoryList\n"
"</></>\n");
-
+
if (zcl->data1_categoryList)
{
node_cl = data1_search_tag(zei->dh, zcl->data1_categoryList,
nmem_malloc(zei->nmem, sizeof(**zsuip));
if (node_type && node_type->u.data.len > 0)
- (*zsuip)->info.index_type = node_type->u.data.data[0];
+ (*zsuip)->info.index_type =
+ nmem_strdupn(zei->nmem,
+ node_type->u.data.data,
+ node_type->u.data.len);
else
{
yaz_log(YLOG_WARN, "Missing attribute 'type' in attribute info");
- (*zsuip)->info.index_type = 'w';
+ (*zsuip)->info.index_type = "w";
}
if (node_cat && node_cat->u.data.len > 0)
{
cat = zinfo_index_category_index;
else if (!strncmp(np->u.data.data, "sort", np->u.data.len))
cat = zinfo_index_category_sort;
- else if (!strncmp(np->u.data.data, "alwaysmatches",
+ else if (!strncmp(np->u.data.data, "alwaysmatches",
np->u.data.len))
cat = zinfo_index_category_alwaysmatches;
- else if (!strncmp(np->u.data.data, "anchor",
+ else if (!strncmp(np->u.data.data, "anchor",
np->u.data.len))
cat = zinfo_index_category_anchor;
else
}
if (node_str)
{
- (*zsuip)->info.which = ZEB_SU_STR;
-
- (*zsuip)->info.u.str = nmem_strdupn(zei->nmem,
- node_str->u.data.data,
- node_str->u.data.len);
+ (*zsuip)->info.str = nmem_strdupn(zei->nmem,
+ node_str->u.data.data,
+ node_str->u.data.len);
}
else
{
rec = rec_get(zei->records, zdi->sysno);
zdi->data1_database = read_sgml_rec(zei->dh, zei->nmem, rec);
-
+
node_dbinfo = data1_search_tag(zei->dh, zdi->data1_database,
"/databaseInfo");
assert(node_dbinfo);
"zebraInfo");
if (node_zebra
&& (np = data1_search_tag(zei->dh, node_zebra->child,
- "recordBytes"))
+ "recordBytes"))
&& np->child && np->child->which == DATA1N_data)
zdi->recordBytes = atoi_zn(np->child->u.data.data,
np->child->u.data.len);
if (node_zebra
&& (np = data1_search_tag(zei->dh, node_zebra->child,
- "ordinalDatabase"))
+ "ordinalDatabase"))
&& np->child && np->child->which == DATA1N_data)
zdi->ordinalDatabase = atoi_n(np->child->u.data.data,
np->child->u.data.len);
{
/* remove attribute details keys and delete it */
zebAttributeDetails zad = zdi->attributeDetails;
-
+
rec = rec_get(zei->records, zad->sysno);
(*zei->updateFunc)(zei->updateHandle, rec, 0);
- rec_free(&rec);
+ rec_del(zei->records, &rec);
}
/* remove database record keys and delete it */
rec = rec_get(zei->records, zdi->sysno);
(*zei->updateFunc)(zei->updateHandle, rec, 0);
- rec_free(&rec);
+ rec_del(zei->records, &rec);
/* remove from list */
*zdip = zdi->next;
database_n++;
else
database_n = database;
-
+
assert(zei);
if (zei->curDatabaseInfo &&
!STRCASECMP(zei->curDatabaseInfo->databaseName, database))
data1_node *c = data1_search_tag(zei->dh, n->child, "accessInfo");
data1_node *d;
zebAccessObject p;
-
+
if (!c)
{
data1_pr_tree(zei->dh, n, stdout);
zdi->ordinalDatabase = zei->ordinalDatabase++;
zebraExplain_mergeAccessInfo(zei, 0, &zdi->accessInfo);
-
+
assert(zei->dh);
assert(zei->nmem);
zdi->data1_database =
- data1_read_sgml(zei->dh, zei->nmem,
+ data1_read_sgml(zei->dh, zei->nmem,
"<explain><databaseInfo>DatabaseInfo\n"
"</></>\n");
if (!zdi->data1_database)
data1_mk_tag_data_text(zei->dh, node_dbinfo, "name",
database, zei->nmem);
-
+
if (explain_database)
data1_mk_tag_data_text(zei->dh, node_dbinfo, "explainDatabase",
"", zei->nmem);
-
+
data1_mk_tag_data_text(zei->dh, node_dbinfo, "userFee",
"0", zei->nmem);
-
+
data1_mk_tag_data_text(zei->dh, node_dbinfo, "available",
"1", zei->nmem);
-
+
#if ZINFO_DEBUG
data1_pr_tree(zei->dh, zdi->data1_database, stderr);
#endif
assert(zcl);
if (!zcl->dirty)
return ;
- zcl->dirty = 1;
+ zcl->dirty = 0;
node_categoryList = zcl->data1_categoryList;
#if ZINFO_DEBUG
drec = createRecord(zei->records, &sysno);
if (!drec)
return;
-
+
node_ci = data1_search_tag(zei->dh, node_categoryList,
"/categoryList");
assert (node_ci);
node_ci = data1_mk_tag(zei->dh, zei->nmem, "categories", 0 /* attr */,
node_ci);
assert (node_ci);
-
+
for (i = 0; category[i]; i++)
{
data1_node *node_cat = data1_mk_tag(zei->dh, zei->nmem, "category",
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);
}
Record drec;
data1_node *node_adinfo, *node_list, *node_zebra;
struct zebSUInfoB *zsui;
-
+
if (!zad->dirty)
return;
-
+
zad->dirty = 0;
#if ZINFO_DEBUG
- yaz_log(YLOG_LOG, "zebraExplain_writeAttributeDetails");
+ yaz_log(YLOG_LOG, "zebraExplain_writeAttributeDetails");
data1_pr_tree(zei->dh, zad->data1_tree, stderr);
#endif
for (zsui = zad->SUInfo; zsui; zsui = zsui->next)
{
data1_node *node_attr;
- char index_type_str[2];
-
node_attr = data1_mk_tag(zei->dh, zei->nmem, "attr", 0 /* attr */,
node_list);
- index_type_str[0] = zsui->info.index_type;
- index_type_str[1] = '\0';
data1_mk_tag_data_text(zei->dh, node_attr, "type",
- index_type_str, zei->nmem);
- if (zsui->info.which == ZEB_SU_STR)
- {
- data1_mk_tag_data_text(zei->dh, node_attr, "str",
- zsui->info.u.str, zei->nmem);
- }
+ zsui->info.index_type, zei->nmem);
+ data1_mk_tag_data_text(zei->dh, node_attr, "str",
+ zsui->info.str, zei->nmem);
data1_mk_tag_data_int(zei->dh, node_attr, "ordinal",
zsui->info.ordinal, zei->nmem);
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);
}
int sgml_len;
Record drec;
data1_node *node_dbinfo, *node_count, *node_zebra;
-
+
if (!zdi->dirty)
return;
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);
}
for (atts = attset->atts; atts; atts = atts->next)
{
data1_node *node_value;
-
+
node_value = data1_mk_tag(zei->dh, zei->nmem, "attributeValue",
0 /* attr */, node_values);
data1_mk_tag_data_text(zei->dh, node_value, "name",
if (o->oid)
attset = data1_attset_search_id(zei->dh, o->oid);
-
+
#if ZINFO_DEBUG
yaz_log(YLOG_LOG, "zebraExplain_writeAttributeSet %s",
- attset ? attset->name : "<unknown>");
+ attset ? attset->name : "<unknown>");
#endif
drec = createRecord(zei->records, &o->sysno);
if (attset && attset->name)
data1_mk_tag_data_text(zei->dh, node_attinfo,
"name", attset->name, zei->nmem);
-
+
node_attributes = data1_mk_tag_uni(zei->dh, zei->nmem,
"attributes", node_attinfo);
node_atttype = data1_mk_tag_uni(zei->dh, zei->nmem,
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);
}
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_lookup_attr_str(ZebraExplainInfo zei,
+int zebraExplain_lookup_attr_str(ZebraExplainInfo zei,
zinfo_index_category_t cat,
- int index_type,
+ const char *index_type,
const char *str)
{
struct zebSUInfoB **zsui;
assert(zei->curDatabaseInfo);
for (zsui = &zei->curDatabaseInfo->attributeDetails->SUInfo;
*zsui; zsui = &(*zsui)->next)
- if ( (index_type == -1 || (*zsui)->info.index_type == index_type)
+ if ( (index_type == 0
+ || !strcmp((*zsui)->info.index_type, index_type))
&& (*zsui)->info.cat == cat
- && (*zsui)->info.which == ZEB_SU_STR
- && !yaz_matchstr((*zsui)->info.u.str, str))
+ && !yaz_matchstr((*zsui)->info.str, str))
{
struct zebSUInfoB *zsui_this = *zsui;
}
int zebraExplain_trav_ord(ZebraExplainInfo zei, void *handle,
- int (*f)(void *handle, int ord))
+ int (*f)(void *handle, int ord,
+ const char *index_type,
+ const char *string_index,
+ zinfo_index_category_t cat))
{
struct zebDatabaseInfoB *zdb = zei->curDatabaseInfo;
if (zdb)
{
struct zebSUInfoB *zsui = zdb->attributeDetails->SUInfo;
for ( ;zsui; zsui = zsui->next)
- (*f)(handle, zsui->info.ordinal);
+ (*f)(handle, zsui->info.ordinal,
+ zsui->info.index_type, zsui->info.str,
+ zsui->info.cat);
}
return 0;
}
if ((*zsui)->info.ordinal == ord)
{
struct zebSUInfoB *zsui_this = *zsui;
-
+
/* take it out of the list and move to front */
*zsui = (*zsui)->next;
zsui_this->next = zdb->attributeDetails->SUInfo;
}
int zebraExplain_lookup_ord(ZebraExplainInfo zei, int ord,
- int *index_type,
+ const char **index_type,
const char **db,
const char **string_index)
{
zsui = zebraExplain_get_sui_info(zei, ord, 0, db);
if (zsui)
{
- if (zsui->info.which == ZEB_SU_STR)
- if (string_index)
- *string_index = zsui->info.u.str;
+ if (string_index)
+ *string_index = zsui->info.str;
if (index_type)
*index_type = zsui->info.index_type;
return 0;
Odr_oid *oid)
{
zebAccessObject ao;
-
+
for (ao = *op; ao; ao = ao->next)
if (!oid_oidcmp(oid, ao->oid))
break;
struct zebSUInfoB *zebraExplain_add_sui_info(ZebraExplainInfo zei,
zinfo_index_category_t cat,
- int index_type)
+ const char *index_type)
{
struct zebSUInfoB *zsui;
zei->curDatabaseInfo->attributeDetails->SUInfo = zsui;
zei->curDatabaseInfo->attributeDetails->dirty = 1;
zei->dirty = 1;
- zsui->info.index_type = index_type;
+ zsui->info.index_type = nmem_strdup(zei->nmem, index_type);
zsui->info.cat = cat;
zsui->info.doc_occurrences = 0;
zsui->info.term_occurrences = 0;
return zsui;
}
-int zebraExplain_add_attr_str(ZebraExplainInfo zei,
+int zebraExplain_add_attr_str(ZebraExplainInfo zei,
zinfo_index_category_t cat,
- int index_type,
+ const char *index_type,
const char *index_name)
{
struct zebSUInfoB *zsui = zebraExplain_add_sui_info(zei, cat, index_type);
- zsui->info.which = ZEB_SU_STR;
- zsui->info.u.str = nmem_strdup(zei->nmem, index_name);
+ zsui->info.str = nmem_strdup(zei->nmem, index_name);
return zsui->info.ordinal;
}
memset(recordAttr, '\0', sizeof(*recordAttr));
rec->info[recInfo_attr] = (char *) recordAttr;
rec->size[recInfo_attr] = sizeof(*recordAttr);
-
+
recordAttr->recordSize = 0;
recordAttr->recordOffset = 0;
recordAttr->runNumber = zei->runNumber;
adds attributeSet (in AccessInfo area) to DatabaseInfo if it doesn't
exist for the database.
- If the database doesn't exist globally (in TargetInfo) an
+ If the database doesn't exist globally (in TargetInfo) an
AttributeSetInfo must be added (globally).
*/
/*
* Local variables:
* c-basic-offset: 4
+ * c-file-style: "Stroustrup"
* indent-tabs-mode: nil
* End:
* vim: shiftwidth=4 tabstop=8 expandtab
projects / idzebra-moved-to-github.git / blobdiff