Error code should only be checked when ZEBRA_FAIL is returned.
Updated sort test t4.c to really do sorting!
dnl Zebra, Index Data ApS, 1995-2005
-dnl $Id: configure.in,v 1.121 2005-05-09 11:39:57 adam Exp $
+dnl $Id: configure.in,v 1.122 2005-05-11 12:39:36 adam Exp $
dnl
AC_INIT(include/idzebra/version.h)
AM_INIT_AUTOMAKE(idzebra,1.4.0)
fi
dnl
dnl ------ YAZ
-YAZ_INIT($yazflag,2.1.3)
+YAZ_INIT($yazflag,2.1.5)
YAZ_DOC
dnl ----- libXSLT
AC_SUBST(XSLT_LIBS)
-/* $Id: index.h,v 1.137 2005-05-09 19:57:35 adam Exp $
+/* $Id: index.h,v 1.138 2005-05-11 12:39:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
void *store_data_buf;
size_t store_data_size;
+ NMEM nmem_error;
struct zebra_limit *m_limit;
};
RSET resultSetRef (ZebraHandle zh, const char *resultSetId);
void resultSetDestroy (ZebraHandle zh, int num_names, char **names,
int *statuses);
-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);
-void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
- ZebraSet sset, RSET rset,
- Z_SortKeySpecList *sort_sequence, int *sort_status);
-void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset, NMEM nmem);
+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);
+ZEBRA_RES resultSetSortSingle (ZebraHandle zh, NMEM nmem,
+ ZebraSet sset, RSET rset,
+ Z_SortKeySpecList *sort_sequence,
+ int *sort_status);
+ZEBRA_RES resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset,
+ NMEM nmem);
void resultSetInvalidate (ZebraHandle zh);
int zebra_server_lock_init (ZebraService zh);
Dict dict_open_res (BFiles bfs, const char *name, int cache, int rw,
int compact_flag, Res res);
+void zebra_setError(ZebraHandle zh, int code, const char *addinfo);
+void zebra_setError_zint(ZebraHandle zh, int code, zint i);
+
YAZ_END_CDECL
#endif
-/* $Id: main.c,v 1.123 2005-01-21 13:23:25 adam Exp $
+/* $Id: main.c,v 1.124 2005-05-11 12:39:36 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
);
exit (1);
}
- while ((ret = options ("sVt:c:g:d:m:v:nf:l:L"
- , argv, argc, &arg)) != -2)
+ while ((ret = options("sVt:c:g:d:m:v:nf:l:L", argv, argc, &arg)) != -2)
{
if (ret == 0)
{
zebra_shadow_enable (zh, enable_commit);
}
- if (database && zebra_select_database (zh, database))
+ if (database &&
+ zebra_select_database (zh, database) == ZEBRA_FAIL)
{
- yaz_log(YLOG_FATAL, "Could not select database %s errCode=%d",
+ yaz_log(YLOG_FATAL, "Could not select database %s "
+ "errCode=%d",
database, zebra_errCode(zh) );
exit (1);
}
}
else
{
+ ZEBRA_RES res = ZEBRA_OK;
if (!trans_started)
{
trans_started=1;
- if (zebra_begin_trans (zh, 1))
+ if (zebra_begin_trans (zh, 1) != ZEBRA_OK)
exit(1);
}
switch (cmd)
{
case 'u':
- zebra_repository_update (zh, arg);
+ res = zebra_repository_update (zh, arg);
break;
case 'd':
- zebra_repository_delete (zh, arg);
+ res = zebra_repository_delete (zh, arg);
break;
case 's':
- zebra_repository_show (zh, arg);
+ res = zebra_repository_show (zh, arg);
nsections = 0;
break;
case 'C':
- zebra_create_database(zh, arg);
+ res = zebra_create_database(zh, arg);
break;
case 'D':
- zebra_drop_database(zh, arg);
+ res = zebra_drop_database(zh, arg);
break;
default:
nsections = 0;
}
+ if (res != ZEBRA_OK)
+ {
+ yaz_log(YLOG_WARN, "Operation failed");
+ exit(1);
+ }
log_event_end (NULL, NULL);
}
}
-/* $Id: zebraapi.c,v 1.167 2005-05-09 10:16:13 adam Exp $
+/* $Id: zebraapi.c,v 1.168 2005-05-11 12:39:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
{
ASSERTZH;
yaz_log(log_level, "zebra_flush_reg");
- zh->errCode = 0;
+ zebra_clearError(zh);
zebraExplain_flush (zh->reg->zei, zh);
extract_flushWriteKeys (zh, 1 /* final */);
zh->m_limit = zebra_limit_create(1, 0);
+ zh->nmem_error = nmem_create();
+
return zh;
}
{
ASSERTZH;
yaz_log(log_level, "zebra_admin_shutdown");
- zh->errCode = 0;
+ zebra_clearError(zh);
zebra_mutex_cond_lock (&zh->service->session_lock);
zh->service->stop_flag = 1;
ZebraService zs;
ASSERTZH;
yaz_log(log_level, "zebra_admin_start");
- zh->errCode = 0;
+ zebra_clearError(zh);
zs = zh->service;
zebra_mutex_cond_lock (&zs->session_lock);
zebra_mutex_cond_unlock (&zs->session_lock);
zebra_limit_destroy(zh->m_limit);
+ nmem_destroy(zh->nmem_error);
+
xfree(zh->path_reg);
xfree(zh);
return ZEBRA_OK;
yaz_log(log_level, "map_basenames ");
assert(stream);
- zh->errCode = 0;
-
info.zh = zh;
info.num_bases = *num_bases;
ASSERTZH;
yaz_log(log_level, "zebra_select_database %s",basename);
assert(basename);
- zh->errCode = 0;
return zebra_select_databases (zh, 1, &basename);
}
assert(hits);
assert(setname);
yaz_log(log_level, "zebra_search_rpn");
- zh->errCode = 0;
+ zebra_clearError(zh);
zh->hits = 0;
*hits = 0;
return r;
}
-ZEBRA_RES zebra_records_retrieve (ZebraHandle zh, ODR stream,
- const char *setname,
- Z_RecordComposition *comp,
- oid_value input_format, int num_recs,
- ZebraRetrievalRecord *recs)
+ZEBRA_RES zebra_records_retrieve(ZebraHandle zh, ODR stream,
+ const char *setname,
+ Z_RecordComposition *comp,
+ oid_value input_format, int num_recs,
+ ZebraRetrievalRecord *recs)
{
ZebraMetaRecord *poset;
int i;
assert(num_recs>0);
yaz_log(log_level, "zebra_records_retrieve n=%d", num_recs);
- zh->errCode = 0;
+ zebra_clearError(zh);
if (!zh->res)
{
- zh->errCode = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
- zh->errString = odr_strdup(stream, setname);
+ zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+ setname);
return ZEBRA_FAIL;
}
- zh->errCode = 0;
-
if (zebra_begin_read (zh) == ZEBRA_FAIL)
return ZEBRA_FAIL;
if (!poset)
{
yaz_log (YLOG_DEBUG, "zebraPosSetCreate error");
- zh->errCode = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
- zh->errString = nmem_strdup (stream->mem, setname);
+ zebra_setError(zh, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+ setname);
ret = ZEBRA_FAIL;
}
else
}
else
{
- char num_str[20];
-
- sprintf (num_str, ZINT_FORMAT, pos_array[i]);
- zh->errCode = YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE;
- zh->errString = odr_strdup (stream, num_str);
+ if (ret == ZEBRA_OK) /* only need to set it once */
+ zebra_setError_zint(zh,
+ YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE,
+ pos_array[i]);
ret = ZEBRA_FAIL;
break;
}
assert(is_partial);
assert(entries);
yaz_log(log_level, "zebra_scan");
- zh->errCode = 0;
+ zebra_clearError(zh);
if (zebra_begin_read (zh) == ZEBRA_FAIL)
{
*entries = 0;
Z_SortKeySpecList *sort_sequence,
int *sort_status)
{
+ ZEBRA_RES res;
ASSERTZH;
assert(stream);
assert(num_input_setnames>0);
assert(sort_sequence);
assert(sort_status);
yaz_log(log_level, "zebra_sort");
- zh->errCode = 0;
- if (zebra_begin_read (zh) == ZEBRA_FAIL)
+ zebra_clearError(zh);
+ if (zebra_begin_read(zh) == ZEBRA_FAIL)
return ZEBRA_FAIL;
- resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
- output_setname, sort_sequence, sort_status);
- return zebra_end_read(zh);
+ res = resultSetSort(zh, stream->mem, num_input_setnames, input_setnames,
+ output_setname, sort_sequence, sort_status);
+ zebra_end_read(zh);
+ return res;
}
int zebra_deleteResultSet(ZebraHandle zh, int function,
ASSERTZH;
assert(statuses);
yaz_log(log_level, "zebra_deleteResultSet n=%d",num_setnames);
- zh->errCode = 0;
+ zebra_clearError(zh);;
if (zebra_begin_read(zh))
return Z_DeleteStatus_systemProblemAtTarget;
switch (function)
const char *zebra_errString (ZebraHandle zh)
{
- const char *e="";
+ const char *e = 0;
if (zh)
e= diagbib1_str (zh->errCode);
yaz_log(log_level, "zebra_errString: %s",e);
char *zebra_errAdd (ZebraHandle zh)
{
- char *a="";
+ char *a = 0;
if (zh)
a= zh->errString;
yaz_log(log_level, "zebra_errAdd: %s",a);
ZebraService zs;
ASSERTZH;
- zh->errCode = 0;
+ zebra_clearError(zh);
zs= zh->service;
sprintf(u, "perm.%.30s", user ? user : "anonymous");
ASSERTZH;
yaz_log(log_level, "zebra_admin_import_begin db=%s rt=%s",
database, record_type);
- zh->errCode = 0;
+ zebra_clearError(zh);
if (zebra_select_database(zh, database) == ZEBRA_FAIL)
return ZEBRA_FAIL;
return zebra_begin_trans(zh, 1);
{
ASSERTZH;
yaz_log(log_level, "zebra_admin_import_end");
- zh->errCode = 0;
+ zebra_clearError(zh);
return zebra_end_trans(zh);
}
int i;
ASSERTZH;
yaz_log(log_level, "zebra_admin_import_segment");
- zh->errCode = 0;
+ zebra_clearError(zh);
for (i = 0; i<segment->num_segmentRecords; i++)
{
Z_NamePlusRecord *npr = segment->segmentRecords[i];
assert(rec_buf);
yaz_log(log_level, "zebra_admin_exchange_record ac=%d", action);
- zh->errCode = 0;
+ zebra_clearError(zh);
if (!recid_buf || recid_len <= 0 || recid_len >= sizeof(recid_z))
return ZEBRA_FAIL;
ZEBRA_RES ret = ZEBRA_OK;
ASSERTZH;
yaz_log(log_level, "zebra_drop_database");
- zh->errCode = 0;
+ zebra_clearError(zh);
if (zebra_select_database (zh, database) == ZEBRA_FAIL)
return ZEBRA_FAIL;
ASSERTZH;
yaz_log(log_level, "zebra_create_database %s", database);
assert(database);
- zh->errCode = 0;
+ zebra_clearError(zh);
if (zebra_select_database (zh, database) == ZEBRA_FAIL)
return ZEBRA_FAIL;
/* explainDatabase */))
{
zebra_end_trans (zh);
- zh->errCode = YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
- zh->errString = "database already exist";
+ zebra_setError(zh, YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED, database);
return ZEBRA_FAIL;
}
return zebra_end_trans (zh);
assert(input_str);
assert(output_str);
yaz_log(log_level, "zebra_string_norm ");
- zh->errCode = 0;
+ zebra_clearError(zh);
if (!zh->reg->zebra_maps)
return -1;
wrbuf = zebra_replace(zh->reg->zebra_maps, reg_id, "",
FILE *f;
ASSERTZH;
yaz_log(log_level, "zebra_set_state v=%d seq=%d", val, seqno);
- zh->errCode = 0;
+ zebra_clearError(zh);
sprintf (state_fname, "state.%s.LCK", zh->reg_name);
fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
ASSERTZH;
yaz_log(log_level, "zebra_get_state ");
- zh->errCode = 0;
+ zebra_clearError(zh);
sprintf (state_fname, "state.%s.LCK", zh->reg_name);
fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
f = fopen (fname, "r");
zebra_select_default_database(zh);
if (!zh->res)
{
- zh->errCode = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
- zh->errString = "zebra_begin_trans: no database selected";
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "zebra_begin_trans: no database selected");
return ZEBRA_FAIL;
}
ASSERTZHRES;
{
if (rw && !strchr(zh->user_perm, 'w'))
{
- zh->errCode =
- YAZ_BIB1_ES_PERMISSION_DENIED_ON_ES_CANNOT_MODIFY_OR_DELETE;
- zh->errString = 0;
+ zebra_setError(
+ zh,
+ YAZ_BIB1_ES_PERMISSION_DENIED_ON_ES_CANNOT_MODIFY_OR_DELETE,
+ 0);
return ZEBRA_FAIL;
}
}
}
if (zh->trans_no != 1)
{
- zh->errCode = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
- zh->errString = "zebra_begin_trans: write trans not allowed within read trans";
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "zebra_begin_trans: no write trans within read");
return ZEBRA_FAIL;
}
if (zh->reg)
}
zh->trans_w_no = zh->trans_no;
- zh->errCode = 0;
+ zebra_clearError(zh);
zh->records_inserted = 0;
zh->records_updated = 0;
zh->trans_no--;
zh->trans_w_no = 0;
- zh->errCode = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
- zh->errString = "zebra_begin_trans: cannot open register";
- yaz_log(YLOG_FATAL, zh->errString);
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "zebra_begin_trans: cannot open register");
+ yaz_log(YLOG_FATAL, "%s", zh->errString);
return ZEBRA_FAIL;
}
}
zebra_flush_reg (zh);
return ZEBRA_OK;
}
- zh->errCode = 0;
+ zebra_clearError(zh);
#if HAVE_SYS_TIMES_H
times (&zh->tms1);
#endif
if (!zh->res || !zh->reg)
{
- zh->errCode = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
- zh->errString = "zebra_end_trans: no open transaction";
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "zebra_end_trans: no open transaction");
return ZEBRA_FAIL;
}
if (zh->trans_no != zh->trans_w_no)
{
ASSERTZH;
assert(path);
- zh->errCode = 0;
+ zebra_clearError(zh);
yaz_log (log_level, "updating %s", path);
repositoryUpdate (zh, path);
return zh->errCode;
{
ASSERTZH;
assert(path);
- zh->errCode = 0;
+ zebra_clearError(zh);
yaz_log (log_level, "deleting %s", path);
repositoryDelete (zh, path);
return zh->errCode;
ASSERTZH;
assert(path);
yaz_log(log_level, "zebra_repository_show");
- zh->errCode = 0;
+ zebra_clearError(zh);
repositoryShow (zh, path);
return zh->errCode;
}
const char *rval;
BFiles bfs;
ASSERTZH;
- zh->errCode = 0;
+ zebra_clearError(zh);
zebra_select_default_database(zh);
if (!zh->res)
BFiles bfs = 0;
ASSERTZH;
yaz_log(log_level, "zebra_init");
- zh->errCode = 0;
+ zebra_clearError(zh);
zebra_select_default_database(zh);
if (!zh->res)
{
- zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
+ "cannot select default database");
return ZEBRA_FAIL;
}
rval = res_get (zh->res, "shadow");
bfs = bfs_create (res_get (zh->res, "register"), zh->path_reg);
if (!bfs)
+ {
+ zebra_setError(zh, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, "bfs_create");
return ZEBRA_FAIL;
+ }
if (rval && *rval)
bf_cache (bfs, rval);
BFiles bfs;
ASSERTZH;
yaz_log(log_level, "zebra_compact");
- zh->errCode = 0;
+ zebra_clearError(zh);
if (!zh->res)
{
zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
{
ASSERTZH;
yaz_log(log_level, "zebra_shadow_enable");
- zh->errCode = 0;
+ zebra_clearError(zh);
zh->shadow_enable = value;
}
ASSERTZH;
assert(encoding);
yaz_log(log_level, "zebra_octet_term_encoding");
- zh->errCode = 0;
+ zebra_clearError(zh);
if (zh->iconv_to_utf8 != 0)
yaz_iconv_close(zh->iconv_to_utf8);
{
ASSERTZH;
yaz_log(log_level, "zebra_record_encoding");
- zh->errCode = 0;
+ zebra_clearError(zh);
xfree(zh->record_encoding);
zh->record_encoding = 0;
if (encoding)
assert(name);
assert(value);
yaz_log(log_level, "zebra_set_resource %s:%s", name, value);
- zh->errCode = 0;
+ zebra_clearError(zh);
res_set(zh->res, name, value);
}
assert(name);
assert(defaultvalue);
v = res_get_def (zh->res, name, (char *)defaultvalue);
- zh->errCode = 0;
+ zebra_clearError(zh);
yaz_log(log_level, "zebra_get_resource %s:%s", name, v);
return v;
}
zh->m_limit = zebra_limit_create(complement_flag, ids);
return ZEBRA_OK;
}
+
+/*
+ Set Error code + addinfo
+*/
+void zebra_setError(ZebraHandle zh, int code, const char *addinfo)
+{
+ zh->errCode = code;
+ nmem_reset(zh->nmem_error);
+ zh->errString = addinfo ? nmem_strdup(zh->nmem_error, addinfo) : 0;
+}
+
+void zebra_setError_zint(ZebraHandle zh, int code, zint i)
+{
+ char vstr[60];
+ sprintf(vstr, ZINT_FORMAT, i);
+
+ zh->errCode = code;
+ nmem_reset(zh->nmem_error);
+ zh->errString = nmem_strdup(zh->nmem_error, vstr);
+}
+
-/* $Id: zrpn.c,v 1.190 2005-05-09 13:24:09 adam Exp $
+/* $Id: zrpn.c,v 1.191 2005-05-11 12:39:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
strcat(term_tmp, ")");
break;
default:
- *error_code = 117;
+ *error_code = YAZ_BIB1_UNSUPP_RELATION_ATTRIBUTE;
return 0;
}
return 1;
if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
{
- zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
- zh->errString = basenames[base_no];
+ zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
+ basenames[base_no]);
return ZEBRA_FAIL;
}
if (xpath_use > 0 && use_value == -2)
{
if (relation_error)
{
- zh->errCode = relation_error;
+ zebra_setError(zh, relation_error, 0);
return ZEBRA_FAIL;
}
*term_sub = 0;
strcat(term_dict, ")");
break;
default:
- zh->errCode = YAZ_BIB1_UNSUPP_TRUNCATION_ATTRIBUTE;
- zh->errString = nmem_strdup_i(stream, truncation_value);
+ zebra_setError_zint(zh,
+ YAZ_BIB1_UNSUPP_TRUNCATION_ATTRIBUTE,
+ truncation_value);
return ZEBRA_FAIL;
}
if (attr_ok)
}
if (!bases_ok)
{
- zh->errCode = errCode;
- zh->errString = errString;
+ zebra_setError(zh, errCode, errString);
return ZEBRA_FAIL;
}
*term_sub = termp;
if (ret == (size_t)(-1))
{
ret = yaz_iconv(zh->iconv_to_utf8, 0, 0, 0, 0);
- zh->errCode =
- YAZ_BIB1_QUERY_TERM_INCLUDES_CHARS_THAT_DO_NOT_TRANSLATE_INTO_;
- return -1;
+ zebra_setError(
+ zh,
+ YAZ_BIB1_QUERY_TERM_INCLUDES_CHARS_THAT_DO_NOT_TRANSLATE_INTO_,
+ 0);
+ return ZEBRA_FAIL;
}
*outbuf = 0;
}
termz[sizez] = '\0';
break;
default:
- zh->errCode = YAZ_BIB1_UNSUPP_CODED_VALUE_FOR_TERM;
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_CODED_VALUE_FOR_TERM, 0);
return ZEBRA_FAIL;
}
return ZEBRA_OK;
xfree(grep_info->isam_p_buf);
}
-static int grep_info_prepare(ZebraHandle zh,
- Z_AttributesPlusTerm *zapt,
- struct grep_info *grep_info,
- int reg_type,
- NMEM stream)
+static ZEBRA_RES grep_info_prepare(ZebraHandle zh,
+ Z_AttributesPlusTerm *zapt,
+ struct grep_info *grep_info,
+ int reg_type)
{
AttrType termset;
int termset_value_numeric;
grep_info->termset = 0;
if (!zapt)
- return 0;
+ return ZEBRA_OK;
attr_init(&termset, zapt, 8);
termset_value_numeric =
attr_find_ex(&termset, NULL, &termset_value_string);
grep_info->termset = resultSetAdd(zh, termset_name, 1);
if (!grep_info->termset)
{
- zh->errCode = YAZ_BIB1_ILLEGAL_RESULT_SET_NAME;
- zh->errString = nmem_strdup(stream, termset_name);
- return -1;
+ zebra_setError(zh, YAZ_BIB1_ILLEGAL_RESULT_SET_NAME, termset_name);
+ return ZEBRA_FAIL;
}
}
- return 0;
+ return ZEBRA_OK;
}
*num_result_sets = 0;
*term_dst = 0;
- if (grep_info_prepare(zh, zapt, &grep_info, reg_type, stream))
+ if (grep_info_prepare(zh, zapt, &grep_info, reg_type) == ZEBRA_FAIL)
return ZEBRA_FAIL;
while(1)
{
sprintf(term_tmp, "(0*%d)", term_value);
break;
default:
- *error_code = 117;
+ *error_code = YAZ_BIB1_UNSUPP_RELATION_ATTRIBUTE;
return 0;
}
yaz_log(log_level_rpn, "dict_lookup_grep: %s", term_tmp);
}
if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
{
- zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
- zh->errString = basenames[base_no];
- return -1;
+ zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
+ basenames[base_no]);
+ return ZEBRA_FAIL;
}
for (local_attr = attp.local_attributes; local_attr;
local_attr = local_attr->next)
}
if (!prefix_len)
{
- errCode = YAZ_BIB1_UNSUPP_USE_ATTRIBUTE;
- errString = nmem_strdup_i(stream, use_value);
+ zebra_setError_zint(zh, YAZ_BIB1_UNSUPP_USE_ATTRIBUTE, use_value);
continue;
}
bases_ok++;
{
if (relation_error)
{
- zh->errCode = relation_error;
- zh->errString = 0;
+ zebra_setError(zh, relation_error, 0);
return ZEBRA_FAIL;
}
*term_sub = 0;
}
if (!bases_ok)
{
- zh->errCode = errCode;
- zh->errString = errString;
+ zebra_setError(zh, errCode, errString);
return ZEBRA_FAIL;
}
*term_sub = termp;
int alloc_sets = 0;
yaz_log(log_level_rpn, "APT_numeric t='%s'", termz);
- if (grep_info_prepare(zh, zapt, &grep_info, reg_type, stream))
+ if (grep_info_prepare(zh, zapt, &grep_info, reg_type) == ZEBRA_FAIL)
return ZEBRA_FAIL;
while (1)
{
int term_type = Z_Term_characterString;
const char *flags = "void";
- if (grep_info_prepare(zh, 0 /* zapt */, &grep_info, '0', stream))
+ if (grep_info_prepare(zh, 0 /* zapt */, &grep_info, '0') == ZEBRA_FAIL)
return rsnull_create(rset_nmem, kc);
if (ord < 0)
return rset;
}
-static RSET rpn_search_xpath(ZebraHandle zh,
- oid_value attributeSet,
- int num_bases, char **basenames,
- NMEM stream, const char *rank_type, RSET rset,
- int xpath_len, struct xpath_location_step *xpath,
- NMEM rset_nmem,
- struct rset_key_control *kc)
+static
+ZEBRA_RES rpn_search_xpath(ZebraHandle zh,
+ oid_value attributeSet,
+ int num_bases, char **basenames,
+ NMEM stream, const char *rank_type, RSET rset,
+ int xpath_len, struct xpath_location_step *xpath,
+ NMEM rset_nmem,
+ RSET *rset_out,
+ struct rset_key_control *kc)
{
oid_value curAttributeSet = attributeSet;
int base_no;
int i;
if (xpath_len < 0)
- return rset;
+ {
+ *rset_out = rset;
+ return ZEBRA_OK;
+ }
yaz_log(YLOG_DEBUG, "xpath len=%d", xpath_len);
for (i = 0; i<xpath_len; i++)
if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
{
- zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
- zh->errString = basenames[base_no];
- return rset;
+ zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
+ basenames[base_no]);
+ *rset_out = rset;
+ return ZEBRA_FAIL;
}
while (--level >= 0)
{
first_path = 0;
}
}
-
- return rset;
+ *rset_out = rset;
+ return ZEBRA_OK;
}
static ZEBRA_RES rpn_search_APT(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
}
else
{
- zh->errCode = YAZ_BIB1_UNSUPP_STRUCTURE_ATTRIBUTE;
- return ZEBRA_FAIL;
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_STRUCTURE_ATTRIBUTE, 0);
+ res = ZEBRA_FAIL;
}
if (res != ZEBRA_OK)
return res;
if (!*rset)
return ZEBRA_FAIL;
- *rset = rpn_search_xpath(zh, attributeSet, num_bases, basenames,
- stream, rank_type, *rset,
- xpath_len, xpath, rset_nmem, kc);
- if (!*rset)
- return ZEBRA_FAIL;
- return ZEBRA_OK;
+ return rpn_search_xpath(zh, attributeSet, num_bases, basenames,
+ stream, rank_type, *rset,
+ xpath_len, xpath, rset_nmem, rset, kc);
}
static ZEBRA_RES rpn_search_structure(ZebraHandle zh, Z_RPNStructure *zs,
case Z_Operator_prox:
if (zop->u.prox->which != Z_ProximityOperator_known)
{
- zh->errCode = YAZ_BIB1_UNSUPP_PROX_UNIT_CODE;
+ zebra_setError(zh,
+ YAZ_BIB1_UNSUPP_PROX_UNIT_CODE,
+ 0);
return ZEBRA_FAIL;
}
if (*zop->u.prox->u.known != Z_ProxUnit_word)
{
- char *val = (char *) nmem_malloc(stream, 16);
- zh->errCode = YAZ_BIB1_UNSUPP_PROX_UNIT_CODE;
- zh->errString = val;
- sprintf(val, "%d", *zop->u.prox->u.known);
+ zebra_setError_zint(zh,
+ YAZ_BIB1_UNSUPP_PROX_UNIT_CODE,
+ *zop->u.prox->u.known);
return ZEBRA_FAIL;
}
else
}
break;
default:
- zh->errCode = YAZ_BIB1_OPERATOR_UNSUPP;
+ zebra_setError(zh, YAZ_BIB1_OPERATOR_UNSUPP, 0);
return ZEBRA_FAIL;
}
*num_result_sets = 1;
rset = resultSetRef(zh, zs->u.simple->u.resultSetId);
if (!rset)
{
- zh->errCode = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
- zh->errString =
- nmem_strdup(stream, zs->u.simple->u.resultSetId);
+ zebra_setError(zh,
+ YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
+ zs->u.simple->u.resultSetId);
return ZEBRA_FAIL;
}
rset_dup(rset);
}
else
{
- zh->errCode = YAZ_BIB1_UNSUPP_SEARCH;
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, 0);
return ZEBRA_FAIL;
}
*num_result_sets = 1;
}
else
{
- zh->errCode = YAZ_BIB1_UNSUPP_SEARCH;
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_SEARCH, 0);
return ZEBRA_FAIL;
}
return ZEBRA_OK;
rank_type, &complete_flag, &sort_flag))
{
*num_entries = 0;
- zh->errCode = YAZ_BIB1_UNSUPP_ATTRIBUTE_TYPE;
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_ATTRIBUTE_TYPE, 0);
return ZEBRA_FAIL;
}
yaz_log(YLOG_DEBUG, "use_value = %d", use_value);
if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
{
- zh->errString = basenames[base_no];
- zh->errCode = YAZ_BIB1_DATABASE_UNAVAILABLE;
+ zebra_setError(zh, YAZ_BIB1_DATABASE_UNAVAILABLE,
+ basenames[base_no]);
*num_entries = 0;
return ZEBRA_FAIL;
}
{
errCode = YAZ_BIB1_UNSUPP_USE_ATTRIBUTE;
if (use_string)
- errString = odr_strdup(stream, use_string);
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_USE_ATTRIBUTE,
+ use_string);
else
- {
- char val_str[32];
- sprintf(val_str, "%d", use_value);
- errString = odr_strdup(stream, val_str);
- }
+ zebra_setError_zint(zh, YAZ_BIB1_UNSUPP_USE_ATTRIBUTE,
+ use_value);
}
else
- errCode = YAZ_BIB1_UNSUPP_ATTRIBUTE_SET;
+ {
+ zebra_setError(zh, YAZ_BIB1_UNSUPP_ATTRIBUTE_SET, 0);
+ }
continue;
}
}
}
if (!bases_ok && errCode)
{
- zh->errCode = errCode;
- zh->errString = errString;
+ zebra_setError(zh, errCode, errString);
*num_entries = 0;
return ZEBRA_FAIL;
}
-/* $Id: zserver.c,v 1.131 2005-04-15 10:47:49 adam Exp $
+/* $Id: zserver.c,v 1.132 2005-05-11 12:39:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
#include <yaz/log.h>
#include <yaz/ill.h>
#include <yaz/yaz-util.h>
+#include <yaz/diagbib1.h>
#include <sys/types.h>
if (!(zh = zebra_open (sob->handle)))
{
yaz_log (YLOG_WARN, "Failed to read config `%s'", sob->configname);
- r->errcode = 1;
+ r->errcode = YAZ_BIB1_PERMANENT_SYSTEM_ERROR;
return r;
}
r->handle = zh;
passwd = idPass->password;
}
}
- if (zebra_auth (zh, user, passwd))
+ if (zebra_auth(zh, user, passwd) != ZEBRA_OK)
{
- r->errcode = 222;
+ r->errcode = YAZ_BIB1_INIT_AC_BAD_USERID_AND_OR_PASSWORD;
r->errstring = user;
return r;
}
zint zhits = 0;
ZEBRA_RES res;
- r->hits = 0;
- r->errcode = 0;
- r->errstring = NULL;
-
- if (zebra_select_databases (zh, r->num_bases,
- (const char **) r->basenames))
+ res = zebra_select_databases (zh, r->num_bases,
+ (const char **) r->basenames);
+ if (res != ZEBRA_OK)
{
zebra_result (zh, &r->errcode, &r->errstring);
return 0;
switch (r->query->which)
{
case Z_Query_type_1: case Z_Query_type_101:
- res = zebra_search_RPN (zh, r->stream, r->query->u.type_1,
- r->setname, &zhits);
- if (zebra_errCode(zh) == 0)
+ res = zebra_search_RPN(zh, r->stream, r->query->u.type_1,
+ r->setname, &zhits);
+ if (res != ZEBRA_OK)
+ zebra_result(zh, &r->errcode, &r->errstring);
+ else
{
if (zhits > 2147483646)
r->hits = 2147483647;
r->hits = (int) zhits;
search_terms (zh, r);
}
- else
- zebra_result (zh, &r->errcode, &r->errstring);
break;
case Z_Query_type_2:
- r->errcode = 107;
+ r->errcode = YAZ_BIB1_QUERY_TYPE_UNSUPP;
r->errstring = "type-2";
break;
default:
- r->errcode = 107;
+ r->errcode = YAZ_BIB1_QUERY_TYPE_UNSUPP;
}
return 0;
}
{
ZebraHandle zh = (ZebraHandle) handle;
ZebraRetrievalRecord retrievalRecord;
+ ZEBRA_RES res;
retrievalRecord.position = r->number;
r->last_in_set = 0;
- zebra_records_retrieve (zh, r->stream, r->setname, r->comp,
+ res = zebra_records_retrieve (zh, r->stream, r->setname, r->comp,
r->request_format, 1, &retrievalRecord);
- zebra_result (zh, &r->errcode, &r->errstring);
- /* non Surrogate Diagnostic OR Surrogate Diagnostic */
- if (r->errcode == 0 && retrievalRecord.errCode)
+ if (res != ZEBRA_OK)
+ {
+ /* non-surrogate diagnostic */
+ zebra_result (zh, &r->errcode, &r->errstring);
+ }
+ else if (retrievalRecord.errCode)
{
+ /* surrogate diagnostic (diagnostic per record) */
r->surrogate_flag = 1;
r->errcode = retrievalRecord.errCode;
r->errstring = retrievalRecord.errString;
r->basename = retrievalRecord.base;
}
- else if (r->errcode == 0) /* Database Record */
+ else
{
- r->errcode = 0;
r->basename = retrievalRecord.base;
r->record = retrievalRecord.buf;
r->len = retrievalRecord.len;
ZebraScanEntry *entries;
ZebraHandle zh = (ZebraHandle) handle;
int is_partial, i;
+ ZEBRA_RES res;
- if (zebra_select_databases (zh, r->num_bases,
- (const char **) r->basenames))
+ res = zebra_select_databases(zh, r->num_bases,
+ (const char **) r->basenames);
+ if (res != ZEBRA_OK)
{
zebra_result (zh, &r->errcode, &r->errstring);
return 0;
}
if (r->step_size != 0 && *r->step_size != 0) {
- r->errcode = 205; /* "Only zero step size supported for Scan" */
+ r->errcode = YAZ_BIB1_ONLY_ZERO_STEP_SIZE_SUPPORTED_FOR_SCAN;
r->errstring = 0;
return 0;
}
r->entries = (struct scan_entry *)
odr_malloc (r->stream, sizeof(*r->entries) * r->num_entries);
- zebra_scan (zh, r->stream, r->term,
- r->attributeset,
- &r->term_position,
- &r->num_entries, &entries, &is_partial);
- if (is_partial)
- r->status = BEND_SCAN_PARTIAL;
+ res = zebra_scan(zh, r->stream, r->term,
+ r->attributeset,
+ &r->term_position,
+ &r->num_entries, &entries, &is_partial);
+ if (res == ZEBRA_OK)
+ {
+ if (is_partial)
+ r->status = BEND_SCAN_PARTIAL;
+ else
+ r->status = BEND_SCAN_SUCCESS;
+ for (i = 0; i < r->num_entries; i++)
+ {
+ r->entries[i].term = entries[i].term;
+ r->entries[i].occurrences = entries[i].occurrences;
+ }
+ }
else
- r->status = BEND_SCAN_SUCCESS;
- for (i = 0; i < r->num_entries; i++)
{
- r->entries[i].term = entries[i].term;
- r->entries[i].occurrences = entries[i].occurrences;
+ r->status = BEND_SCAN_PARTIAL;
+ zebra_result(zh, &r->errcode, &r->errstring);
}
- zebra_result (zh, &r->errcode, &r->errstring);
return 0;
}
else
{
yaz_log (YLOG_WARN, "no database supplied for ES Update");
- rr->errcode = 1008;
+ rr->errcode =
+ YAZ_BIB1_ES_MISSING_MANDATORY_PARAMETER_FOR_SPECIFIED_FUNCTION_;
rr->errstring = "database";
return 0;
}
}
if (oident && oident->value != VAL_TEXT_XML)
{
- rr->errcode = 224;
+ rr->errcode = YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "only XML update supported";
break;
}
if (!action)
{
- rr->errcode = 224;
+ rr->errcode =
+ YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "unsupported ES Update action";
break;
}
action);
if (r)
{
- rr->errcode = 224;
+ rr->errcode =
+ YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "record exchange failed";
break;
}
0);
if (r == ZEBRA_FAIL)
{
- rr->errcode = 224;
+ rr->errcode =
+ YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "insert_record failed";
}
break;
1);
if (r == ZEBRA_FAIL)
{
- rr->errcode = 224;
+ rr->errcode =
+ YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "update_record failed";
}
break;
0);
if (r == ZEBRA_FAIL)
{
- rr->errcode = 224;
+ rr->errcode =
+ YAZ_BIB1_ES_IMMEDIATE_EXECUTION_FAILED;
rr->errstring = "delete_record failed";
}
break;
{
yaz_log (YLOG_WARN, "Unknown Extended Service(%d)",
rr->esr->taskSpecificParameters->which);
- rr->errcode = 221;
+ rr->errcode = YAZ_BIB1_ES_EXTENDED_SERVICE_TYPE_UNSUPP;
}
return 0;
-/* $Id: zsets.c,v 1.81 2005-04-25 11:54:08 adam Exp $
+/* $Id: zsets.c,v 1.82 2005-05-11 12:39:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
#endif
#include "index.h"
+#include <yaz/diagbib1.h>
#include <rset.h>
#define SORT_IDX_ENTRYSIZE 64
};
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;
{
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");
oident *attrset;
Z_SortKeySpecList *sort_sequence;
int sort_status, i;
- ZEBRA_RES res;
+ ZEBRA_RES res = ZEBRA_OK;
- zh->errCode = 0;
- zh->errString = NULL;
zh->hits = 0;
sort_sequence = (Z_SortKeySpecList *)
sset->rset = 0;
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;
}
int i;
ZEBRA_RES res;
- zh->errCode = 0;
- zh->errString = NULL;
zh->hits = 0;
zebraSet = resultSetAdd (zh, setname, 1);
if (statuses)
for (i = 0; i<num; i++)
statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
- zh->errCode = 0;
- zh->errString = NULL;
while (*ss)
{
int i = -1;
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;
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++;
}
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]))
{
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;
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);
+ /* FIXME - pass a TERMID *, and use it for something below !! */
while (rset_read (rfd, &key, &termid))
- /* FIXME - pass a TERMID *, and use it for something below !! */
{
zint this_sys = key.mem[0];
kno++;
}
}
rset_close (rfd);
- yaz_log(log_level_sorting, ZINT_FORMAT " keys, " ZINT_FORMAT " sysnos, sort",
+ 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,
+ yaz_log(log_level_sort, "term=\"%s\" type=%s count=" ZINT_FORMAT,
terms[i]->name, terms[i]->flags, rset_count(terms[i]->rset));
*sort_status = Z_SortResponse_success;
+ return ZEBRA_OK;
}
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;
sort_info->num_entries = 0;
zebraSet->hits = 0;
rset_getterms(rset, 0, 0, &n);
+ yaz_log(YLOG_LOG, "Got %d terms", n);
terms = (TERMID *) nmem_malloc(nmem, sizeof(*terms)*n);
rset_getterms(rset, terms, n, &numTerms);
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;
(*rc->end) (zh->reg, handle);
}
rset_close (rfd);
-
- 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, rset_count(terms[i]->rset));
}
+ return ZEBRA_OK;
}
ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
-/* $Id: t4.c,v 1.16 2005-04-14 12:01:50 adam Exp $
+/* $Id: t4.c,v 1.17 2005-05-11 12:39:37 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
for (i = 0; i<2; i++)
{
+ ZEBRA_RES ret;
ZebraRetrievalRecord retrievalRecord[NUMBER_TO_FETCH_MAX];
char setname[20];
int j;
zint hits;
sprintf(setname, "s%d", i+1);
- zebra_search_RPN(zh, odr_input, query, setname, &hits);
+ ret = zebra_search_RPN(zh, odr_input, query, setname, &hits);
+ if (ret != ZEBRA_OK)
+ {
+ int code = zebra_errCode(zh);
+ yaz_log(YLOG_WARN, "Unexpected error code=%d", code);
+ exit(1);
+ }
if (hits != number_to_be_inserted)
{
yaz_log(YLOG_WARN, "Unexpected hit count " ZINT_FORMAT
for (j = 0; j < number_to_fetch; j++)
retrievalRecord[j].position = j+1;
- zebra_records_retrieve(zh, odr_output, setname, 0,
- VAL_TEXT_XML, number_to_fetch, retrievalRecord);
-
- if (zebra_errCode(zh))
+ ret = zebra_records_retrieve(zh, odr_output, setname, 0,
+ VAL_TEXT_XML, number_to_fetch,
+ retrievalRecord);
+ if (ret != ZEBRA_OK)
{
+ int code = zebra_errCode(zh);
yaz_log(YLOG_FATAL, "zebra_records_retrieve returned error %d",
- zebra_errCode(zh));
+ code);
exit(1);
}
-/* $Id: t7.c,v 1.8 2005-03-09 12:14:42 adam Exp $
+/* $Id: t7.c,v 1.9 2005-05-11 12:39:38 adam Exp $
Copyright (C) 1995-2005
Index Data ApS
int main(int argc, char **argv)
{
+ const char *setname1 = "set1";
+ const char *setname2 = "set2";
+ const char *setname3 = "set3";
+ int status;
+ ZEBRA_RES ret;
ZebraService zs = start_up(0, argc, argv);
ZebraHandle zh = zebra_open (zs);
-
- const char *setname1="set1";
- const char *setname2="set2";
- const char *setname3="set3";
- int status;
- int rc;
ODR odr_input = odr_createmem (ODR_DECODE);
ODR odr_output = odr_createmem (ODR_ENCODE);
YAZ_PQF_Parser parser = yaz_pqf_create();
- Z_RPNQuery *query = yaz_pqf_parse(parser, odr_input,
- "@attr 1=4 my");
- Z_SortKeySpecList *spec =
- yaz_sort_spec (odr_output, "@attr 1=4 id");
+ Z_RPNQuery *query = yaz_pqf_parse(parser, odr_input, "@attr 1=4 my");
+ Z_SortKeySpecList *spec = yaz_sort_spec (odr_output, "1=4 <");
zint hits;
init_data(zh, recs);
zebra_begin_trans(zh, 0);
- zebra_search_RPN(zh, odr_input, query, setname1, &hits);
+ ret = zebra_search_RPN(zh, odr_input, query, setname1, &hits);
+ if (ret == ZEBRA_FAIL)
+ {
+ int code = zebra_errCode(zh);
+ printf("search returned ERROR, OK was expected ret=%d "
+ "code=%d\n", ret, code);
+ }
- rc=zebra_sort(zh, odr_output, 1, &setname1, setname2, spec, &status);
- if (rc)
+ ret = zebra_sort(zh, odr_output, 1, &setname1, setname2, spec, &status);
+ if (ret == ZEBRA_FAIL)
{
- printf("sort A returned %d %d \n",rc,status);
+ int code = zebra_errCode(zh);
+ printf("sort A returned ERROR, OK was expected ret=%d status=%d "
+ "code=%d\n", ret, status, code);
exit(1);
}
- rc=zebra_sort(zh, odr_output, 1, &setname2, setname3, spec, &status);
- if (rc)
+ ret = zebra_sort(zh, odr_output, 1, &setname2, setname3, spec, &status);
+ if (ret == ZEBRA_FAIL)
{
- printf("sort B returned %d %d \n",rc,status);
+ int code = zebra_errCode(zh);
+ printf("sort B returned ERROR, OK was expected ret=%d status=%d "
+ "code=%d\n", ret, status, code);
exit(1);
}
+ spec = yaz_sort_spec(odr_output, "1=5 <"); /* invalid sort spec */
+
+ ret = zebra_sort(zh, odr_output, 1, &setname1, setname2, spec, &status);
+ if (ret == ZEBRA_OK)
+ {
+ printf("sort C returned OK, ERROR was expected ret=%d status=%d\n",
+ ret, status);
+ exit(1);
+ }
zebra_end_trans(zh);
yaz_pqf_destroy(parser);
projects / idzebra-moved-to-github.git / commitdiff