-/* $Id: zebraapi.c,v 1.135 2004-10-07 14:18:23 heikki Exp $
+/* $Id: zebraapi.c,v 1.140 2004-11-19 10:27:03 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
#define ASSERTZHRES assert(zh && zh->service && zh->res)
#define ASSERTZS assert(zs)
-#define LOG_API LOG_APP2
+static int log_level=0;
+static int log_level_initialized=0;
static Res zebra_open_res (ZebraHandle zh);
static void zebra_close_res (ZebraHandle zh);
{
const char *dir ;
ASSERTZS;
- yaz_log(LOG_API,"zebra_chdir");
+ yaz_log(log_level,"zebra_chdir");
dir = res_get (zs->global_res, "chdir");
if (!dir)
return;
- logf (LOG_DEBUG, "chdir %s", dir);
+ yaz_log (YLOG_DEBUG, "chdir %s", dir);
#ifdef WIN32
_chdir(dir);
#else
static void zebra_flush_reg (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_flush_reg");
+ yaz_log(log_level,"zebra_flush_reg");
zh->errCode=0;
zebraExplain_flush (zh->reg->zei, zh);
{
ZebraHandle zh;
const char *default_encoding;
- ASSERTZS;
- yaz_log(LOG_API,"zebra_open");
+ if (!log_level_initialized)
+ {
+ log_level=yaz_log_module_level("zebraapi");
+ log_level_initialized=1;
+ }
+
+ yaz_log(log_level,"zebra_open");
if (!zs)
return 0;
zh = (ZebraHandle) xmalloc (sizeof(*zh));
- yaz_log (LOG_DEBUG, "zebra_open zs=%p returns %p", zs, zh);
+ yaz_log (YLOG_DEBUG, "zebra_open zs=%p returns %p", zs, zh);
zh->service = zs;
zh->reg = 0; /* no register attached yet */
zh->iconv_to_utf8 =
yaz_iconv_open ("UTF-8", default_encoding);
if (zh->iconv_to_utf8 == 0)
- yaz_log (LOG_WARN, "iconv: %s to UTF-8 unsupported",
+ yaz_log (YLOG_WARN, "iconv: %s to UTF-8 unsupported",
default_encoding);
zh->iconv_from_utf8 =
yaz_iconv_open (default_encoding, "UTF-8");
if (zh->iconv_to_utf8 == 0)
- yaz_log (LOG_WARN, "iconv: UTF-8 to %s unsupported",
+ yaz_log (YLOG_WARN, "iconv: UTF-8 to %s unsupported",
default_encoding);
zebra_mutex_cond_lock (&zs->session_lock);
{
Res res;
- yaz_log(LOG_API,"zebra_start %s",configName);
+ if (!log_level_initialized)
+ {
+ log_level=yaz_log_module_level("zebraapi");
+ log_level_initialized=1;
+ }
+
+ yaz_log(log_level,"zebra_start %s",configName);
assert(configName);
if ((res = res_open (configName, def_res, over_res)))
{
ZebraService zh = xmalloc (sizeof(*zh));
- yaz_log (LOG_DEBUG, "Read resources `%s'", configName);
+ yaz_log (YLOG_DEBUG, "Read resources `%s'", configName);
zh->global_res = res;
zh->configName = xstrdup(configName);
{
zh->passwd_db = passwd_db_open ();
if (!zh->passwd_db)
- logf (LOG_WARN|LOG_ERRNO, "passwd_db_open failed");
+ yaz_log (YLOG_WARN|YLOG_ERRNO, "passwd_db_open failed");
else
passwd_db_file (zh->passwd_db,
res_get (zh->global_res, "passwd"));
if (v)
{
page_size = atoi(v);
- yaz_log(LOG_LOG, "Using custom dictionary page size %d for %s",
+ yaz_log(YLOG_LOG, "Using custom dictionary page size %d for %s",
page_size, name);
}
return dict_open(bfs, name, cache, rw, compact_flag, page_size);
assert (res);
- yaz_log (LOG_DEBUG, "zebra_register_open rw=%d useshadow=%d p=%p n=%s rp=%s",
+ yaz_log (YLOG_DEBUG, "zebra_register_open rw=%d useshadow=%d p=%p n=%s rp=%s",
rw, useshadow, reg, name, reg_path ? reg_path : "(none)");
reg->dh = data1_createx (DATA1_FLAG_XML);
getcwd(cwd, sizeof(cwd)-1);
profilePath = res_get_def(res, "profilePath", DEFAULT_PROFILE_PATH);
- yaz_log(LOG_DEBUG, "profilePath=%s cwd=%s", profilePath, cwd);
+ yaz_log(YLOG_DEBUG, "profilePath=%s cwd=%s", profilePath, cwd);
data1_set_tabpath (reg->dh, profilePath);
data1_set_tabroot (reg->dh, reg_path);
zebraRankInstall (reg, rank1_class);
zebraRankInstall (reg, rankzv_class);
- zebraRankInstall (reg, rankliv_class);
recordCompression = res_get_def (res, "recordCompression", "none");
if (!strcmp (recordCompression, "none"))
if (!(reg->records = rec_open (reg->bfs, rw, record_compression)))
{
- logf (LOG_WARN, "rec_open");
+ yaz_log (YLOG_WARN, "rec_open");
return 0;
}
if (rw)
}
if (!(reg->dict = dict_open_res (reg->bfs, FNAME_DICT, 40, rw, 0, res)))
{
- logf (LOG_WARN, "dict_open");
+ yaz_log (YLOG_WARN, "dict_open");
return 0;
}
if (!(reg->sortIdx = sortIdx_open (reg->bfs, rw)))
{
- logf (LOG_WARN, "sortIdx_open");
+ yaz_log (YLOG_WARN, "sortIdx_open");
return 0;
}
if (res_get_match (res, "isam", "s", ISAM_DEFAULT))
if (!(reg->isams = isams_open (reg->bfs, FNAME_ISAMS, rw,
key_isams_m(res, &isams_m))))
{
- logf (LOG_WARN, "isams_open");
+ yaz_log (YLOG_WARN, "isams_open");
return 0;
}
}
if (!(reg->isamc = isc_open (reg->bfs, FNAME_ISAMC,
rw, key_isamc_m(res, &isamc_m))))
{
- logf (LOG_WARN, "isc_open");
+ yaz_log (YLOG_WARN, "isc_open");
return 0;
}
}
if (!(reg->isamb = isamb_open (reg->bfs, "isamb",
rw, key_isamc_m(res, &isamc_m), 0)))
{
- logf (LOG_WARN, "isamb_open");
+ yaz_log (YLOG_WARN, "isamb_open");
return 0;
}
}
if (!(reg->isamb = isamb_open (reg->bfs, "isamb",
rw, key_isamc_m(res, &isamc_m), 1)))
{
- logf (LOG_WARN, "isamb_open");
+ yaz_log (YLOG_WARN, "isamb_open");
return 0;
}
}
if (!(reg->isamb = isamb_open (reg->bfs, "isamb",
rw, key_isamc_m(res, &isamc_m), -1)))
{
- logf (LOG_WARN, "isamb_open");
+ yaz_log (YLOG_WARN, "isamb_open");
return 0;
}
}
explain_extract);
if (!reg->zei)
{
- logf (LOG_WARN, "Cannot obtain EXPLAIN information");
+ yaz_log (YLOG_WARN, "Cannot obtain EXPLAIN information");
return 0;
}
reg->active = 2;
- yaz_log (LOG_DEBUG, "zebra_register_open ok p=%p", reg);
+ yaz_log (YLOG_DEBUG, "zebra_register_open ok p=%p", reg);
return reg;
}
int zebra_admin_shutdown (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_admin_shutdown");
+ yaz_log(log_level,"zebra_admin_shutdown");
zh->errCode=0;
zebra_mutex_cond_lock (&zh->service->session_lock);
{
ZebraService zs;
ASSERTZH;
- yaz_log(LOG_API,"zebra_admin_start");
+ yaz_log(log_level,"zebra_admin_start");
zh->errCode=0;
zs = zh->service;
zebra_mutex_cond_lock (&zs->session_lock);
{
ASSERTZS;
assert(reg);
- yaz_log(LOG_DEBUG, "zebra_register_close p=%p", reg);
+ yaz_log(YLOG_DEBUG, "zebra_register_close p=%p", reg);
reg->stop_flag = 0;
zebra_chdir (zs);
if (reg->records)
{
if (!zs)
return 0;
- yaz_log (LOG_API, "zebra_stop");
+ yaz_log (log_level, "zebra_stop");
while (zs->sessions)
{
struct zebra_session **sp;
int i;
- yaz_log(LOG_API,"zebra_close");
+ yaz_log(log_level,"zebra_close");
if (!zh)
return 0;
ASSERTZH;
zh->errCode=0;
zs = zh->service;
- yaz_log (LOG_DEBUG, "zebra_close zh=%p", zh);
+ yaz_log (YLOG_DEBUG, "zebra_close zh=%p", zh);
resultSetDestroy (zh, -1, 0, 0);
if (zh->reg)
}
else
{
- yaz_log (LOG_WARN, "no register root specified");
+ yaz_log (YLOG_WARN, "no register root specified");
return 0; /* no path for register - fail! */
}
return res;
struct map_baseinfo *p = &info;
int i;
ASSERTZH;
- yaz_log(LOG_API,"map_basenames ");
+ yaz_log(log_level,"map_basenames ");
assert(stream);
zh->errCode=0;
*num_bases = info.new_num_bases;
*basenames = info.new_basenames;
for (i = 0; i<*num_bases; i++)
- logf (LOG_DEBUG, "base %s", (*basenames)[i]);
+ yaz_log (YLOG_DEBUG, "base %s", (*basenames)[i]);
}
int zebra_select_database (ZebraHandle zh, const char *basename)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_select_database %s",basename);
+ yaz_log(log_level,"zebra_select_database %s",basename);
assert(basename);
zh->errCode=0;
return zebra_select_databases (zh, 1, &basename);
ASSERTZH;
assert(basenames);
- yaz_log(LOG_API,"zebra_select_databases n=%d [0]=%s",
+ yaz_log(log_level,"zebra_select_databases n=%d [0]=%s",
num_bases,basenames[0]);
zh->errCode=0;
assert(query);
assert(hits);
assert(setname);
- yaz_log(LOG_API,"zebra_search_rpn");
+ yaz_log(log_level,"zebra_search_rpn");
zh->errCode=0;
zh->hits = 0;
*hits = 0;
if (zebra_begin_read (zh))
return 1;
- zebra_livcode_transform(zh, query);
-
resultSetAddRPN (zh, odr_extract_mem(o), query,
zh->num_basenames, zh->basenames, setname);
while (i--) maxhits *= 10;
}
if (zh->hits > maxhits) { /* too large for yaz to handle */
- logf(LOG_DEBUG,"limiting hits to "ZINT_FORMAT, maxhits);
+ yaz_log(YLOG_DEBUG,"limiting hits to "ZINT_FORMAT, maxhits);
*hits=maxhits;
}
else
assert(recs);
assert(num_recs>0);
- yaz_log(LOG_API,"zebra_records_retrieve n=%d",num_recs);
+ yaz_log(log_level,"zebra_records_retrieve n=%d",num_recs);
zh->errCode=0;
if (!zh->res)
poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
if (!poset)
{
- logf (LOG_DEBUG, "zebraPosSetCreate error");
+ yaz_log (YLOG_DEBUG, "zebraPosSetCreate error");
zh->errCode = 30;
zh->errString = nmem_strdup (stream->mem, setname);
ret = -1;
&recs[i].len,
&recs[i].base);
recs[i].errString = NULL;
+ recs[i].score=poset[i].score;
+ recs[i].sysno=poset[i].sysno;
}
else
{
assert(num_entries);
assert(is_partial);
assert(entries);
- yaz_log(LOG_API,"zebra_scan");
+ yaz_log(log_level,"zebra_scan");
zh->errCode=0;
if (zebra_begin_read (zh))
{
assert(input_setnames);
assert(sort_sequence);
assert(sort_status);
- yaz_log(LOG_API,"zebra_sort");
+ yaz_log(log_level,"zebra_sort");
zh->errCode=0;
if (zebra_begin_read (zh))
return 1;
assert(num_setnames>0);
assert(setnames);
assert(statuses);
- yaz_log(LOG_API,"zebra_deleleResultSet n=%d",num_setnames);
+ yaz_log(log_level,"zebra_deleleResultSet n=%d",num_setnames);
zh->errCode=0;
if (zebra_begin_read(zh))
return Z_DeleteStatus_systemProblemAtTarget;
{
if (zh)
{
- yaz_log(LOG_API,"zebra_errCode: %d",zh->errCode);
+ yaz_log(log_level,"zebra_errCode: %d",zh->errCode);
return zh->errCode;
}
- yaz_log(LOG_API,"zebra_errCode: o");
+ yaz_log(log_level,"zebra_errCode: o");
return 0;
}
const char *e="";
if (zh)
e= diagbib1_str (zh->errCode);
- yaz_log(LOG_API,"zebra_errString: %s",e);
+ yaz_log(log_level,"zebra_errString: %s",e);
return e;
}
char *a="";
if (zh)
a= zh->errString;
- yaz_log(LOG_API,"zebra_errAdd: %s",a);
+ yaz_log(log_level,"zebra_errAdd: %s",a);
return a;
}
const char *record_type)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_admin_import_begin db=%s rt=%s",
+ yaz_log(log_level,"zebra_admin_import_begin db=%s rt=%s",
database, record_type);
zh->errCode=0;
if (zebra_select_database(zh, database))
int zebra_admin_import_end (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_admin_import_end");
+ yaz_log(log_level,"zebra_admin_import_end");
zh->errCode=0;
zebra_end_trans (zh);
return 0;
SYSNO sysno;
int i;
ASSERTZH;
- yaz_log(LOG_API,"zebra_admin_import_segment");
+ yaz_log(log_level,"zebra_admin_import_segment");
zh->errCode=0;
for (i = 0; i<segment->num_segmentRecords; i++)
{
assert(action>0 && action <=4);
assert(rec_buf);
- yaz_log(LOG_API,"zebra_admin_exchange_record ac=%d", action);
+ yaz_log(log_level,"zebra_admin_exchange_record ac=%d", action);
zh->errCode=0;
if (!recid_buf || recid_len <= 0 || recid_len >= sizeof(recid_z))
{
int ret = 0;
ASSERTZH;
- yaz_log(LOG_API,"zebra_drop_database");
+ yaz_log(log_level,"zebra_drop_database");
zh->errCode = 0;
if (zebra_select_database (zh, database))
}
else
{
- yaz_log(LOG_WARN, "drop database only supported for isam:b");
+ yaz_log(YLOG_WARN, "drop database only supported for isam:b");
ret = -1;
}
zebra_end_trans (zh);
int zebra_create_database (ZebraHandle zh, const char *database)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_create_database %s",database);
+ yaz_log(log_level,"zebra_create_database %s",database);
assert(database);
zh->errCode=0;
ASSERTZH;
assert(input_str);
assert(output_str);
- yaz_log(LOG_API,"zebra_string_norm ");
+ yaz_log(log_level,"zebra_string_norm ");
zh->errCode=0;
if (!zh->reg->zebra_maps)
return -1;
long p = getpid();
FILE *f;
ASSERTZH;
- yaz_log(LOG_API,"zebra_set_state v=%d seq=%d", val, seqno);
+ yaz_log(log_level,"zebra_set_state v=%d seq=%d", val, seqno);
zh->errCode=0;
sprintf (state_fname, "state.%s.LCK", zh->reg_name);
fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
f = fopen (fname, "w");
- yaz_log (LOG_DEBUG, "zebra_set_state: %c %d %ld", val, seqno, p);
+ yaz_log (YLOG_DEBUG, "zebra_set_state: %c %d %ld", val, seqno, p);
fprintf (f, "%c %d %ld\n", val, seqno, p);
fclose (f);
xfree (fname);
FILE *f;
ASSERTZH;
- yaz_log(LOG_API,"zebra_get_state ");
+ yaz_log(log_level,"zebra_get_state ");
zh->errCode=0;
sprintf (state_fname, "state.%s.LCK", zh->reg_name);
fname = zebra_mk_fname (res_get(zh->res, "lockDir"), state_fname);
return -1;
}
ASSERTZHRES;
- yaz_log(LOG_API,"zebra_begin_trans rw=%d",rw);
+ yaz_log(log_level,"zebra_begin_trans rw=%d",rw);
if (zh->user_perm)
{
zebra_get_state (zh, &val, &seqno);
if (val == 'c')
{
- yaz_log (LOG_WARN, "previous transaction didn't finish commit");
+ yaz_log (YLOG_WARN, "previous transaction didn't finish commit");
zebra_unlock (zh->lock_shadow);
zebra_unlock (zh->lock_normal);
zebra_commit (zh);
{
BFiles bfs = bfs_create (res_get (zh->res, "shadow"),
zh->path_reg);
- yaz_log (LOG_WARN, "previous transaction didn't reach commit");
+ yaz_log (YLOG_WARN, "previous transaction didn't reach commit");
bf_commitClean (bfs, rval);
bfs_destroy (bfs);
}
else
{
- yaz_log (LOG_WARN, "your previous transaction didn't finish");
+ yaz_log (YLOG_WARN, "your previous transaction didn't finish");
}
}
break;
}
if (pass == 2)
{
- yaz_log (LOG_FATAL, "zebra_begin_trans couldn't finish commit");
+ yaz_log (YLOG_FATAL, "zebra_begin_trans couldn't finish commit");
abort();
return -1;
}
zh->errCode = 2;
zh->errString = "zebra_begin_trans: cannot open register";
- yaz_log(LOG_FATAL, zh->errString);
+ yaz_log(YLOG_FATAL, zh->errString);
return -1;
}
}
dirty = 1;
else if (seqno != zh->reg->seqno)
{
- yaz_log (LOG_DEBUG, "reopen seqno cur/old %d/%d",
+ yaz_log (YLOG_DEBUG, "reopen seqno cur/old %d/%d",
seqno, zh->reg->seqno);
dirty = 1;
}
else if (zh->reg->last_val != val)
{
- yaz_log (LOG_DEBUG, "reopen last cur/old %d/%d",
+ yaz_log (YLOG_DEBUG, "reopen last cur/old %d/%d",
val, zh->reg->last_val);
dirty = 1;
}
int zebra_end_trans (ZebraHandle zh)
{
- ASSERTZH;
ZebraTransactionStatus dummy;
- yaz_log(LOG_API,"zebra_end_trans");
+ ASSERTZH;
+ yaz_log(log_level,"zebra_end_trans");
return zebra_end_transaction(zh, &dummy);
}
ASSERTZH;
assert(status);
- yaz_log(LOG_API,"zebra_end_transaction");
+ yaz_log(log_level,"zebra_end_transaction");
status->processed = 0;
status->inserted = 0;
zh->trans_no--;
zh->trans_w_no = 0;
- yaz_log (LOG_DEBUG, "zebra_end_trans");
+ yaz_log (YLOG_DEBUG, "zebra_end_trans");
rval = res_get (zh->res, "shadow");
zebraExplain_runNumberIncrement (zh->reg->zei, 1);
zebra_register_close (zh->service, zh->reg);
zh->reg = 0;
- yaz_log (LOG_LOG, "Records: "ZINT_FORMAT" i/u/d "
+ yaz_log (YLOG_LOG, "Records: "ZINT_FORMAT" i/u/d "
ZINT_FORMAT"/"ZINT_FORMAT"/"ZINT_FORMAT,
zh->records_processed, zh->records_inserted,
zh->records_updated, zh->records_deleted);
if (val != 'd')
{
BFiles bfs = bfs_create (rval, zh->path_reg);
- yaz_log (LOG_DEBUG, "deleting shadow val=%c", val);
+ yaz_log (YLOG_DEBUG, "deleting shadow val=%c", val);
bf_commitClean (bfs, rval);
bfs_destroy (bfs);
}
}
#if HAVE_SYS_TIMES_H
times (&zh->tms2);
- logf (LOG_LOG, "user/system: %ld/%ld",
+ yaz_log (YLOG_LOG, "user/system: %ld/%ld",
(long) (zh->tms2.tms_utime - zh->tms1.tms_utime),
(long) (zh->tms2.tms_stime - zh->tms1.tms_stime));
ASSERTZH;
assert(path);
zh->errCode=0;
- logf (LOG_API, "updating %s", path);
+ yaz_log (log_level, "updating %s", path);
repositoryUpdate (zh, path);
return zh->errCode;
}
ASSERTZH;
assert(path);
zh->errCode=0;
- logf (LOG_API, "deleting %s", path);
+ yaz_log (log_level, "deleting %s", path);
repositoryDelete (zh, path);
return zh->errCode;
}
{
ASSERTZH;
assert(path);
- yaz_log(LOG_API,"zebra_repository_show");
+ yaz_log(log_level,"zebra_repository_show");
zh->errCode=0;
repositoryShow (zh, path);
return zh->errCode;
rval = res_get (zh->res, "shadow");
if (!rval)
{
- logf (LOG_WARN, "Cannot perform commit");
- logf (LOG_WARN, "No shadow area defined");
+ yaz_log (YLOG_WARN, "Cannot perform commit");
+ yaz_log (YLOG_WARN, "No shadow area defined");
return 0;
}
{
zebra_set_state (zh, 'c', seqno);
- logf (LOG_DEBUG, "commit start");
+ yaz_log (YLOG_DEBUG, "commit start");
bf_commitExec (bfs);
#ifndef WIN32
sync ();
#endif
}
- logf (LOG_DEBUG, "commit clean");
+ yaz_log (YLOG_DEBUG, "commit clean");
bf_commitClean (bfs, rval);
seqno++;
zebra_set_state (zh, 'o', seqno);
}
else
{
- logf (LOG_LOG, "nothing to commit");
+ yaz_log (YLOG_LOG, "nothing to commit");
}
bfs_destroy (bfs);
int zebra_clean (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_clean");
+ yaz_log(log_level,"zebra_clean");
return zebra_commit_ex(zh, 1);
}
int zebra_commit (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_commit");
+ yaz_log(log_level,"zebra_commit");
return zebra_commit_ex(zh, 0);
}
const char *rval;
BFiles bfs = 0;
ASSERTZH;
- yaz_log(LOG_API,"zebra_init");
+ yaz_log(log_level,"zebra_init");
zh->errCode=0;
if (!zh->res)
{
BFiles bfs;
ASSERTZH;
- yaz_log(LOG_API,"zebra_compact");
+ yaz_log(log_level,"zebra_compact");
zh->errCode=0;
if (!zh->res)
{
int zebra_result (ZebraHandle zh, int *code, char **addinfo)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_result");
+ yaz_log(log_level,"zebra_result");
*code = zh->errCode;
*addinfo = zh->errString;
return 0;
int zebra_shadow_enable (ZebraHandle zh, int value)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_shadow_enable");
+ yaz_log(log_level,"zebra_shadow_enable");
zh->errCode=0;
zh->shadow_enable = value;
return 0;
{
ASSERTZH;
assert(encoding);
- yaz_log(LOG_API,"zebra_record_encoding");
+ yaz_log(log_level,"zebra_record_encoding");
zh->errCode=0;
xfree (zh->record_encoding);
zh->record_encoding = xstrdup (encoding);
- logf(LOG_DEBUG, "Reset record encoding: %s", encoding);
+ yaz_log(YLOG_DEBUG, "Reset record encoding: %s", encoding);
zh->iconv_to_utf8 =
yaz_iconv_open ("UTF-8", encoding);
if (zh->iconv_to_utf8 == 0)
- yaz_log (LOG_WARN, "iconv: %s to UTF-8 unsupported", encoding);
+ yaz_log (YLOG_WARN, "iconv: %s to UTF-8 unsupported", encoding);
zh->iconv_from_utf8 =
yaz_iconv_open (encoding, "UTF-8");
if (zh->iconv_to_utf8 == 0)
- yaz_log (LOG_WARN, "iconv: UTF-8 to %s unsupported", encoding);
+ yaz_log (YLOG_WARN, "iconv: UTF-8 to %s unsupported", encoding);
return 0;
}
ASSERTZH;
assert(name);
assert(value);
- yaz_log(LOG_API,"zebra_set_resource %s:%s",name,value);
+ yaz_log(log_level,"zebra_set_resource %s:%s",name,value);
zh->errCode=0;
res_set(zh->res, name, value);
return 0;
assert(defaultvalue);
v= res_get_def( zh->res, name, (char *)defaultvalue);
zh->errCode=0;
- yaz_log(LOG_API,"zebra_get_resource %s:%s",name,v);
+ yaz_log(log_level,"zebra_get_resource %s:%s",name,v);
return v;
}
int zebra_trans_no (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_trans_no");
+ yaz_log(log_level,"zebra_trans_no");
return zh->trans_no;
}
int zebra_get_shadow_enable (ZebraHandle zh)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_get_shadow_enable");
+ yaz_log(log_level,"zebra_get_shadow_enable");
return (zh->shadow_enable);
}
int zebra_set_shadow_enable (ZebraHandle zh, int value)
{
ASSERTZH;
- yaz_log(LOG_API,"zebra_set_shadow_enable %d",value);
+ yaz_log(log_level,"zebra_set_shadow_enable %d",value);
zh->shadow_enable = value;
return 0;
}
assert(comp);
assert(recs);
assert(num_recs>0);
- yaz_log(LOG_API,"api_records_retrieve s=%s n=%d",setname,num_recs);
+ yaz_log(log_level,"api_records_retrieve s=%s n=%d",setname,num_recs);
if (!zh->res)
{
poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
if (!poset)
{
- logf (LOG_DEBUG, "zebraPosSetCreate error");
+ yaz_log (YLOG_DEBUG, "zebraPosSetCreate error");
zh->errCode = 30;
zh->errString = nmem_strdup (stream->mem, setname);
}
ASSERTZH;
assert(sysno);
assert(buf);
- yaz_log(LOG_API, "zebra_insert_record sysno=" ZINT_FORMAT, *sysno);
+ yaz_log(log_level, "zebra_insert_record sysno=" ZINT_FORMAT, *sysno);
if (buf_size < 1) buf_size = strlen(buf);
assert(sysno);
assert(buf);
- yaz_log(LOG_API, "zebra_update_record sysno=" ZINT_FORMAT, *sysno);
+ yaz_log(log_level, "zebra_update_record sysno=" ZINT_FORMAT, *sysno);
if (buf_size < 1) buf_size = strlen(buf);
ASSERTZH;
assert(sysno);
assert(buf);
- yaz_log(LOG_API, "zebra_delete_record sysno=" ZINT_FORMAT, *sysno);
+ yaz_log(log_level, "zebra_delete_record sysno=" ZINT_FORMAT, *sysno);
if (buf_size < 1) buf_size = strlen(buf);
assert(pqf_query);
assert(setname);
- yaz_log(LOG_API,"zebra_search_PQF s=%s q=%s",setname, pqf_query);
+ yaz_log(log_level,"zebra_search_PQF s=%s q=%s",setname, pqf_query);
query = p_query_rpn (odr, PROTO_Z3950, pqf_query);
if (!query)
- yaz_log (LOG_WARN, "bad query %s\n", pqf_query);
+ yaz_log (YLOG_WARN, "bad query %s\n", pqf_query);
else
res=zebra_search_RPN (zh, odr, query, setname, &hits);
odr_destroy(odr);
- yaz_log(LOG_API,"Hits: %d",hits);
+ yaz_log(log_level,"Hits: %d",hits);
if (numhits)
*numhits=hits;
assert(output_setname);
assert(input_setnames);
sort_sequence = yaz_sort_spec (stream, sort_spec);
- yaz_log(LOG_API,"sort (FIXME) ");
+ yaz_log(log_level,"sort (FIXME) ");
if (!sort_sequence)
{
- logf(LOG_WARN,"invalid sort specs '%s'", sort_spec);
+ yaz_log(YLOG_WARN,"invalid sort specs '%s'", sort_spec);
zh->errCode = 207;
return -1;
}
projects / idzebra-moved-to-github.git / blobdiff