X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=index%2Fzsets.c;h=d729f93d429f391e013d42471af1bae96b31b067;hb=989564485b832bc896b2c0bf73c8e4a7f28f1ad2;hp=37dc5a7cfb015986e27d62a363e1efe919c1243f;hpb=49d0ee122a9f86ec2967b577dcc297c501785edd;p=idzebra-moved-to-github.git

diff --git a/index/zsets.c b/index/zsets.c
index 37dc5a7..d729f93 100644
--- a/index/zsets.c
+++ b/index/zsets.c
@@ -1,4 +1,4 @@
-/* $Id: zsets.c,v 1.80 2005-04-15 10:47:49 adam Exp $
+/* $Id: zsets.c,v 1.84 2005-05-31 07:29:10 adam Exp $
    Copyright (C) 1995-2005
    Index Data ApS
 
@@ -30,6 +30,7 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #endif
 
 #include "index.h"
+#include <yaz/diagbib1.h>
 #include <rset.h>
 
 #define SORT_IDX_ENTRYSIZE 64
@@ -42,6 +43,7 @@ struct zebra_set_term_entry {
     int use;
     char *term;
 };
+
 struct zebra_set {
     char *name;
     RSET rset;
@@ -76,7 +78,7 @@ struct zset_sort_info {
 };
 
 static int log_level_set=0;
-static int log_level_sorting=0;
+static int log_level_sort=0;
 static int log_level_searchhits=0;
 static int log_level_searchterms=0;
 static int log_level_resultsets=0;
@@ -85,7 +87,7 @@ static void loglevels()
 {
     if (log_level_set)
         return;
-    log_level_sorting = yaz_log_module_level("sorting");
+    log_level_sort = yaz_log_module_level("sorting");
     log_level_searchhits = yaz_log_module_level("searchhits");
     log_level_searchterms = yaz_log_module_level("searchterms");
     log_level_resultsets = yaz_log_module_level("resultsets");
@@ -95,13 +97,12 @@ static void loglevels()
 ZEBRA_RES resultSetSearch(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
 			  Z_RPNQuery *rpn, ZebraSet sset)
 {
-    RSET rset;
+    RSET rset = 0;
     oident *attrset;
     Z_SortKeySpecList *sort_sequence;
     int sort_status, i;
+    ZEBRA_RES res = ZEBRA_OK;
 
-    zh->errCode = 0;
-    zh->errString = NULL;
     zh->hits = 0;
 
     sort_sequence = (Z_SortKeySpecList *)
@@ -114,36 +115,30 @@ ZEBRA_RES resultSetSearch(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
         sort_sequence->specs[i] = 0;
     
     attrset = oid_getentbyoid (rpn->attributeSetId);
-    rset = rpn_search_structure (zh, rpn->RPNStructure, attrset->value,
-                                 nmem, rset_nmem,
-                                 sort_sequence,
-				 sset->num_bases, sset->basenames);
-    if (!rset)
+    res = rpn_search_top(zh, rpn->RPNStructure, attrset->value,
+			 nmem, rset_nmem,
+			 sort_sequence,
+			 sset->num_bases, sset->basenames,
+			 &rset);
+    if (res != ZEBRA_OK)
     {
 	sset->rset = 0;
-        return ZEBRA_FAIL;
+        return res;
     }
-
-    if (zh->errCode)
-        yaz_log(YLOG_DEBUG, "search error: %d", zh->errCode);
-    
     for (i = 0; sort_sequence->specs[i]; i++)
         ;
     sort_sequence->num_specs = i;
     if (!i)
-        resultSetRank (zh, sset, rset, rset_nmem);
+    {
+        res = resultSetRank (zh, sset, rset, rset_nmem);
+    }
     else
     {
-        yaz_log(YLOG_DEBUG, "resultSetSortSingle in rpn_search");
-        resultSetSortSingle (zh, nmem, sset, rset,
-                             sort_sequence, &sort_status);
-        if (zh->errCode)
-        {
-            yaz_log(YLOG_DEBUG, "resultSetSortSingle status = %d", zh->errCode);
-        }
+        res = resultSetSortSingle (zh, nmem, sset, rset,
+				   sort_sequence, &sort_status);
     }
     sset->rset = rset;
-    return ZEBRA_OK;
+    return res;
 }
 
 
@@ -155,8 +150,6 @@ ZEBRA_RES resultSetAddRPN (ZebraHandle zh, NMEM m, Z_RPNQuery *rpn,
     int i;
     ZEBRA_RES res;
 
-    zh->errCode = 0;
-    zh->errString = NULL;
     zh->hits = 0;
 
     zebraSet = resultSetAdd (zh, setname, 1);
@@ -328,8 +321,6 @@ void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
     if (statuses)
         for (i = 0; i<num; i++)
             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
-    zh->errCode = 0;
-    zh->errString = NULL;
     while (*ss)
     {
         int i = -1;
@@ -371,9 +362,9 @@ void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
     }
 }
 
-ZebraMetaRecord *zebra_meta_records_create_range (ZebraHandle zh,
-						  const char *name, 
-						  zint start, int num)
+ZebraMetaRecord *zebra_meta_records_create_range(ZebraHandle zh,
+						 const char *name, 
+						 zint start, int num)
 {
     zint pos_small[10];
     zint *pos = pos_small;
@@ -396,8 +387,8 @@ ZebraMetaRecord *zebra_meta_records_create_range (ZebraHandle zh,
     return mr;
 }
 
-ZebraMetaRecord *zebra_meta_records_create (ZebraHandle zh, const char *name, 
-					    int num, zint *positions)
+ZebraMetaRecord *zebra_meta_records_create(ZebraHandle zh, const char *name, 
+					   int num, zint *positions)
 {
     ZebraSet sset;
     ZebraMetaRecord *sr = 0;
@@ -448,7 +439,7 @@ ZebraMetaRecord *zebra_meta_records_create (ZebraHandle zh, const char *name,
                 position = positions[i];
                 if (position > 0 && position <= sort_info->num_entries)
                 {
-                    yaz_log(log_level_sorting, "got pos=" ZINT_FORMAT
+                    yaz_log(log_level_sort, "got pos=" ZINT_FORMAT
 			    " (sorted)", position);
                     sr[i].sysno = sort_info->entries[position-1]->sysno;
                     sr[i].score = sort_info->entries[position-1]->score;
@@ -507,7 +498,7 @@ ZebraMetaRecord *zebra_meta_records_create (ZebraHandle zh, const char *name,
                     if (position == positions[num_i])
                     {
                         sr[num_i].sysno = psysno;
-                        yaz_log(log_level_sorting, "got pos=" ZINT_FORMAT " (unsorted)", position);
+                        yaz_log(log_level_sort, "got pos=" ZINT_FORMAT " (unsorted)", position);
                         sr[num_i].score = -1;
                         num_i++;
                     }
@@ -656,40 +647,40 @@ void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
     new_entry->score = score;
 }
 
-void resultSetSort (ZebraHandle zh, NMEM nmem,
-                    int num_input_setnames, const char **input_setnames,
-                    const char *output_setname,
-                    Z_SortKeySpecList *sort_sequence, int *sort_status)
+ZEBRA_RES resultSetSort(ZebraHandle zh, NMEM nmem,
+			int num_input_setnames, const char **input_setnames,
+			const char *output_setname,
+			Z_SortKeySpecList *sort_sequence, int *sort_status)
 {
     ZebraSet sset;
     RSET rset;
 
     if (num_input_setnames == 0)
     {
-        zh->errCode = 208;
-        return ;
+	zebra_setError(zh, YAZ_BIB1_NO_RESULT_SET_NAME_SUPPLIED_ON_SORT, 0);
+	return ZEBRA_FAIL;
     }
     if (num_input_setnames > 1)
     {
-        zh->errCode = 230;
-        return;
+        zebra_setError(zh, YAZ_BIB1_SORT_TOO_MANY_INPUT_RESULTS, 0);
+	return ZEBRA_FAIL;
     }
     if (!log_level_set)
         loglevels();
-    yaz_log(log_level_sorting, "result set sort input=%s output=%s",
+    yaz_log(log_level_sort, "result set sort input=%s output=%s",
           *input_setnames, output_setname);
     sset = resultSetGet (zh, input_setnames[0]);
     if (!sset)
     {
-        zh->errCode = 30;
-        zh->errString = nmem_strdup (nmem, input_setnames[0]);
-        return;
+	zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+		       input_setnames[0]);
+	return ZEBRA_FAIL;
     }
     if (!(rset = sset->rset))
     {
-        zh->errCode = 30;
-        zh->errString = nmem_strdup (nmem, input_setnames[0]);
-        return;
+	zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+		       input_setnames[0]);
+	return ZEBRA_FAIL;
     }
     if (strcmp (output_setname, input_setnames[0]))
     {
@@ -697,12 +688,14 @@ void resultSetSort (ZebraHandle zh, NMEM nmem,
         sset = resultSetAdd (zh, output_setname, 1);
         sset->rset = rset;
     }
-    resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
+    return resultSetSortSingle (zh, nmem, sset, rset, sort_sequence,
+				sort_status);
 }
 
-void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
-                          ZebraSet sset, RSET rset,
-                          Z_SortKeySpecList *sort_sequence, int *sort_status)
+ZEBRA_RES resultSetSortSingle(ZebraHandle zh, NMEM nmem,
+			      ZebraSet sset, RSET rset,
+			      Z_SortKeySpecList *sort_sequence,
+			      int *sort_status)
 {
     int i;
     int n = 0;
@@ -738,55 +731,60 @@ void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
             sort_criteria[i].relation = 'D';
         else
         {
-            zh->errCode = 214;
-            return;
+	    zebra_setError(zh, YAZ_BIB1_ILLEGAL_SORT_RELATION, 0);
+            return ZEBRA_FAIL;
         }
         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
         {
-            zh->errCode = 210;
-            return;
+	    zebra_setError(zh, YAZ_BIB1_DATABASE_SPECIFIC_SORT_UNSUPP, 0);
+            return ZEBRA_FAIL;
         }
         else if (sks->sortElement->which != Z_SortElement_generic)
         {
-            zh->errCode = 237;
-            return;
+	    zebra_setError(zh, YAZ_BIB1_SORT_ILLEGAL_SORT, 0);
+            return ZEBRA_FAIL;
         }       
         sk = sks->sortElement->u.generic;
         switch (sk->which)
         {
         case Z_SortKey_sortField:
-            yaz_log(log_level_sorting, "Sort: key %d is of type sortField", i+1);
-            zh->errCode = 207;
-            return;
+            yaz_log(log_level_sort, "key %d is of type sortField",
+		    i+1);
+            zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
+            return ZEBRA_FAIL;
         case Z_SortKey_elementSpec:
-            yaz_log(log_level_sorting, "Sort: key %d is of type elementSpec", i+1);
-            zh->errCode = 207;
-            return;
+            yaz_log(log_level_sort, "key %d is of type elementSpec",
+		    i+1);
+            zebra_setError(zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
+            return ZEBRA_FAIL;
         case Z_SortKey_sortAttributes:
-            yaz_log(log_level_sorting, "Sort: key %d is of type sortAttributes", i+1);
+            yaz_log(log_level_sort, "key %d is of type sortAttributes", i+1);
             sort_criteria[i].attrUse =
                 zebra_maps_sort (zh->reg->zebra_maps,
                                  sk->u.sortAttributes,
                                  &sort_criteria[i].numerical);
-            yaz_log(log_level_sorting, "use value = %d", sort_criteria[i].attrUse);
+            yaz_log(log_level_sort, "use value = %d", sort_criteria[i].attrUse);
             if (sort_criteria[i].attrUse == -1)
             {
-                zh->errCode = 116;
-                return;
+		zebra_setError(
+		    zh, YAZ_BIB1_USE_ATTRIBUTE_REQUIRED_BUT_NOT_SUPPLIED, 0); 
+                return ZEBRA_FAIL;
             }
             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
             {
-                zh->errCode = 207;
-                return;
+		zebra_setError(
+		    zh, YAZ_BIB1_CANNOT_SORT_ACCORDING_TO_SEQUENCE, 0);
+                return ZEBRA_FAIL;
             }
             break;
         }
     }
     rfd = rset_open (rset, RSETF_READ);
     while (rset_read (rfd, &key, &termid))
-      /* FIXME - pass a TERMID *, and use it for something below !! */
     {
         zint this_sys = key.mem[0];
+	if (log_level_searchhits)
+	    key_logdump_txt(log_level_searchhits, &key, termid->name);
 	kno++;
         if (this_sys != psysno)
         {
@@ -797,15 +795,16 @@ void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
         }
     }
     rset_close (rfd);
-    yaz_log(log_level_sorting, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
-		    kno, sset->hits);   
+    yaz_log(log_level_sort, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
+	    kno, sset->hits);   
     for (i = 0; i < numTerms; i++)
-        yaz_log(log_level_sorting, "term=\"%s\" type=%s count=" ZINT_FORMAT,
-                 terms[i]->name, terms[i]->flags, rset_count(terms[i]->rset));
+        yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
+                 terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
     *sort_status = Z_SortResponse_success;
+    return ZEBRA_OK;
 }
 
-RSET resultSetRef (ZebraHandle zh, const char *resultSetId)
+RSET resultSetRef(ZebraHandle zh, const char *resultSetId)
 {
     ZebraSet s;
 
@@ -814,24 +813,19 @@ RSET resultSetRef (ZebraHandle zh, const char *resultSetId)
     return NULL;
 }
 
-void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset, NMEM nmem)
+ZEBRA_RES resultSetRank(ZebraHandle zh, ZebraSet zebraSet,
+			RSET rset, NMEM nmem)
 {
-    zint kno = 0;
     struct it_key key;
-    RSFD rfd;
     TERMID termid;
     TERMID *terms;
+    zint kno = 0;
     int numTerms = 0;
     int n = 0;
     int i;
     ZebraRankClass rank_class;
-    struct rank_control *rc;
     struct zset_sort_info *sort_info;
     const char *rank_handler_name = res_get_def(zh->res, "rank", "rank-1");
-    double cur,tot; 
-    zint est=-2; /* -2 not done, -1 can't do, >0 actual estimate*/
-    zint esthits;
-    double ratio;
 
     if (!log_level_set)
         loglevels();
@@ -842,83 +836,65 @@ void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset, NMEM nmem)
     terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
     rset_getterms(rset, terms, n, &numTerms);
 
-    rfd = rset_open (rset, RSETF_READ);
-
-    rank_class = zebraRankLookup (zh, rank_handler_name);
+    rank_class = zebraRankLookup(zh, rank_handler_name);
     if (!rank_class)
     {
         yaz_log(YLOG_WARN, "No such rank handler: %s", rank_handler_name);
-        return;
+	zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, "Cannot find rank handler");
+        return ZEBRA_FAIL;
     }
-    rc = rank_class->control;
-
-    if (rset_read (rfd, &key, &termid))
+    else
     {
-        zint psysno = key.mem[0];
-        int score;
-        void *handle =
-            (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
-                          terms, numTerms);
-        (zebraSet->hits)++;
-        esthits = atoi(res_get_def(zh->res, "estimatehits","0"));
-        if (!esthits) 
-            est = -1; /* can not do */
-        do
-        {
-            zint this_sys = key.mem[0]; /* FIXME - assumes scope==2 */
-            zint seqno = key.mem[key.len-1]; /* FIXME - assumes scope==2 */
-            kno++;
-            key_logdump_txt(log_level_searchhits,&key," Got hit");
-            if (this_sys != psysno)
-            {
-                score = (*rc->calc) (handle, psysno);
-
-                resultSetInsertRank (zh, sort_info, psysno, score, 'A');
-                (zebraSet->hits)++;
-                psysno = this_sys;
-            }
-            (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
-            
-            if ((est==-2) && (zebraSet->hits==esthits))
-            { /* time to estimate the hits */
-                rset_pos(rfd,&cur,&tot); 
-                if (tot>0) {
-                    ratio = cur/tot;
-                    est = (zint)(0.5+zebraSet->hits/ratio);
-                    yaz_log(log_level_searchhits, "Estimating hits (%s) "
-                                  "%0.1f->" ZINT_FORMAT
-                                  "; %0.1f->" ZINT_FORMAT,
-                                  rset->control->desc,
-                                  cur, zebraSet->hits,
-                                  tot, est);
-                    i = 0; /* round to 3 significant digits */
-                    while (est>1000) {
-                        est /= 10;
-                        i++;
-                    }
-                    while (i--)
-			est *= 10;
-                    zebraSet->hits = est;
-                }
-            }
-        }
-        while (rset_read (rfd, &key,&termid) && (est<0) );
-        score = (*rc->calc)(handle, psysno);
-        resultSetInsertRank(zh, sort_info, psysno, score, 'A');
-        (*rc->end) (zh->reg, handle);
+	RSFD rfd = rset_open(rset, RSETF_READ);
+	struct rank_control *rc = rank_class->control;
+	double score;
+	
+	void *handle =
+	    (*rc->begin) (zh->reg, rank_class->class_handle, rset, nmem,
+			  terms, numTerms);
+	zint psysno = 0;
+	while (rset_read(rfd, &key, &termid))
+	{
+	    zint this_sys = key.mem[0];
+	    zint seqno = key.mem[key.len-1];
+	    kno++;
+	    if (log_level_searchhits)
+		key_logdump_txt(log_level_searchhits, &key, termid->name);
+	    if (this_sys != psysno)
+	    {
+		if (rfd->counted_items >= rset->hits_limit)
+		    break;
+		if (psysno)
+		{
+		    score = (*rc->calc) (handle, psysno);
+		    resultSetInsertRank (zh, sort_info, psysno, score, 'A');
+		}
+		psysno = this_sys;
+	    }
+	    (*rc->add) (handle, CAST_ZINT_TO_INT(seqno), termid);
+	}
+	if (psysno)
+	{
+	    score = (*rc->calc)(handle, psysno);
+	    resultSetInsertRank(zh, sort_info, psysno, score, 'A');
+	}
+	(*rc->end) (zh->reg, handle);
+	rset_close (rfd);
     }
-    rset_close (rfd);
+    zebraSet->hits = rset->hits_count;
 
-    yaz_log(log_level_searchterms, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, rank",
-	    kno, zebraSet->hits);
+    yaz_log(log_level_searchterms, ZINT_FORMAT " keys, "
+	    ZINT_FORMAT " sysnos, rank",  kno, zebraSet->hits);
     for (i = 0; i < numTerms; i++)
     {
-        yaz_log(log_level_searchterms, "term=\"%s\" type=%s count=" ZINT_FORMAT,
-                 terms[i]->name, terms[i]->flags, rset_count(terms[i]->rset));
+        yaz_log(log_level_searchterms, "term=\"%s\" type=%s count="
+		ZINT_FORMAT,
+		terms[i]->name, terms[i]->flags, terms[i]->rset->hits_count);
     }
+    return ZEBRA_OK;
 }
 
-ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
+ZebraRankClass zebraRankLookup(ZebraHandle zh, const char *name)
 {
     ZebraRankClass p = zh->reg->rank_classes;
     while (p && strcmp (p->control->name, name))
@@ -932,7 +908,7 @@ ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
     return p;
 }
 
-void zebraRankInstall (struct zebra_register *reg, struct rank_control *ctrl)
+void zebraRankInstall(struct zebra_register *reg, struct rank_control *ctrl)
 {
     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
@@ -943,7 +919,7 @@ void zebraRankInstall (struct zebra_register *reg, struct rank_control *ctrl)
     reg->rank_classes = p;
 }
 
-void zebraRankDestroy (struct zebra_register *reg)
+void zebraRankDestroy(struct zebra_register *reg)
 {
     ZebraRankClass p = reg->rank_classes;
     while (p)
@@ -958,3 +934,101 @@ void zebraRankDestroy (struct zebra_register *reg)
     }
     reg->rank_classes = NULL;
 }
+
+static int trav_rset_for_termids(RSET rset, TERMID *termid_array,
+				 zint *hits_array, int *approx_array)
+{
+    int no = 0;
+    int i;
+    for (i = 0; i<rset->no_children; i++)
+	no += trav_rset_for_termids(rset->children[i],
+				    (termid_array ? termid_array + no : 0),
+				    (hits_array ? hits_array + no : 0),
+				    (approx_array ? approx_array + no : 0));
+    if (rset->term)
+    {
+	if (termid_array)
+	    termid_array[no] = rset->term;
+	if (hits_array)
+	    hits_array[no] = rset->hits_count;
+	if (approx_array)
+	    approx_array[no] = rset->hits_approx;
+#if 0
+	yaz_log(YLOG_LOG, "rset=%p term=%s count=" ZINT_FORMAT,
+		rset, rset->term->name, rset->hits_count);
+#endif
+	no++;
+    }
+    return no;
+}
+
+ZEBRA_RES zebra_result_set_term_no(ZebraHandle zh, const char *setname,
+				   int *num_terms)
+{
+    ZebraSet sset = resultSetGet(zh, setname);
+    *num_terms = 0;
+    if (sset)
+    {
+	*num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
+	return ZEBRA_OK;
+    }
+    return ZEBRA_FAIL;
+}
+
+ZEBRA_RES zebra_result_set_term_info(ZebraHandle zh, const char *setname,
+				     int no, zint *count, int *approx,
+				     char *termbuf, size_t *termlen)
+{
+    ZebraSet sset = resultSetGet(zh, setname);
+    if (sset)
+    {
+	int num_terms = trav_rset_for_termids(sset->rset, 0, 0, 0);
+	if (no >= 0 && no < num_terms)
+	{
+	    TERMID *term_array = xmalloc(num_terms * sizeof(*term_array));
+	    zint *hits_array = xmalloc(num_terms * sizeof(*hits_array));
+	    int *approx_array = xmalloc(num_terms * sizeof(*approx_array));
+	    
+	    trav_rset_for_termids(sset->rset, term_array,
+				  hits_array, approx_array);
+
+	    if (count)
+		*count = hits_array[no];
+	    if (approx)
+		*approx = approx_array[no];
+	    if (termbuf)
+	    {
+		char *inbuf = term_array[no]->name;
+		size_t inleft = strlen(inbuf);
+		size_t outleft = *termlen - 1;
+
+		if (zh->iconv_from_utf8 != 0)
+		{
+		    char *outbuf = termbuf;
+		    size_t ret;
+		    
+		    ret = yaz_iconv(zh->iconv_from_utf8, &inbuf, &inleft,
+				    &outbuf, &outleft);
+		    if (ret == (size_t)(-1))
+			*termlen = 0;
+		    else
+			*termlen = outbuf - termbuf;
+		}
+		else
+		{
+		    if (inleft > outleft)
+			inleft = outleft;
+		    *termlen = inleft;
+		    memcpy(termbuf, inbuf, *termlen);
+		}
+		termbuf[*termlen] = '\0';
+	    }
+
+	    xfree(term_array);
+	    xfree(hits_array);
+	    xfree(approx_array);
+	    return ZEBRA_OK;
+	}
+    }
+    return ZEBRA_FAIL;
+}