X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=index%2Fretrieve.c;h=26279985967edf10f2a6e1fb9bb9f148df25b25f;hp=5e2ed207f68e9cd8fa3ef368be544134083a9e79;hb=3e4a78274a6cb7a99f3e90967ea30c830ffbf8c3;hpb=9252c3f4231f9f3226326ce1360f055bad48b8d1 diff --git a/index/retrieve.c b/index/retrieve.c index 5e2ed20..2627998 100644 --- a/index/retrieve.c +++ b/index/retrieve.c @@ -1,35 +1,24 @@ -/* - * Copyright (C) 1995-1999, Index Data - * All rights reserved. - * Sebastian Hammer, Adam Dickmeiss - * - * $Log: retrieve.c,v $ - * Revision 1.8 1999-03-09 16:27:49 adam - * More work on SDRKit integration. - * - * Revision 1.7 1999/03/02 16:15:43 quinn - * Added "tagsysno" and "tagrank" directives to zebra.cfg. - * - * Revision 1.6 1999/02/18 15:01:25 adam - * Minor changes. - * - * Revision 1.5 1999/02/17 11:29:56 adam - * Fixed in record_fetch. Minor updates to API. - * - * Revision 1.4 1999/02/02 14:51:07 adam - * Updated WIN32 code specific sections. Changed header. - * - * Revision 1.3 1998/10/28 10:54:40 adam - * SDRKit integration. - * - * Revision 1.2 1998/10/16 08:14:33 adam - * Updated record control system. - * - * Revision 1.1 1998/03/05 08:45:13 adam - * New result set model and modular ranking system. Moved towards - * descent server API. System information stored as "SGML" records. - * - */ +/* $Id: retrieve.c,v 1.67 2007-03-19 21:50:39 adam Exp $ + Copyright (C) 1995-2007 + Index Data ApS + +This file is part of the Zebra server. + +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 +Software Foundation; either version 2, or (at your option) any later +version. + +Zebra is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ #include #include @@ -38,215 +27,669 @@ #ifdef WIN32 #include #include -#else +#endif +#if HAVE_UNISTD_H #include #endif -#include -#include "zserver.h" +#include "index.h" +#include +#include -#ifndef ZEBRASDR -#define ZEBRASDR 0 -#endif -#if ZEBRASDR -#include "zebrasdr.h" -#endif +#define ZEBRA_XML_HEADER_STR "reg->zei, *rec); + + if ((*rec)->size[recInfo_storeData] > 0) + zebra_create_stream_mem(stream, (*rec)->info[recInfo_storeData], + (*rec)->size[recInfo_storeData]); + else + { + char full_rep[1024]; + int fd; + + if (zh->path_reg && !yaz_is_abspath((*rec)->info[recInfo_filename])){ + strcpy(full_rep, zh->path_reg); + strcat(full_rep, "/"); + strcat(full_rep, (*rec)->info[recInfo_filename]); + } + else + strcpy(full_rep, (*rec)->info[recInfo_filename]); + + if ((fd = open (full_rep, O_BINARY|O_RDONLY)) == -1){ + yaz_log (YLOG_WARN|YLOG_ERRNO, "Retrieve fail; missing file: %s", + full_rep); + rec_free(rec); + return YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; + } + zebra_create_stream_fd(stream, fd, recordAttr->recordOffset); + } + return 0; +} + -struct fetch_control { - int record_offset; - int record_int_pos; - char *record_int_buf; - int record_int_len; - int fd; -}; -static int record_ext_read (void *fh, char *buf, size_t count) +static int parse_zebra_elem(const char *elem, + const char **index, size_t *index_len, + const char **type, size_t *type_len) { - struct fetch_control *fc = fh; - return read (fc->fd, buf, count); + *index = 0; + *index_len = 0; + + *type = 0; + *type_len = 0; + + if (elem && *elem) + { + char *cp; + /* verify that '::' is in the beginning of *elem + and something more follows */ + if (':' != *elem + || !(elem +1) || ':' != *(elem +1) + || !(elem +2) || '\0' == *(elem +2)) + return 0; + + /* pick out info from string after '::' */ + elem = elem + 2; + cp = strchr(elem, ':'); + + if (!cp) /* index, no colon, no type */ + { + *index = elem; + *index_len = strlen(elem); + } + else if (cp[1] == '\0') /* colon, but no following type */ + { + return 0; + } + else /* index, colon and type */ + { + *index = elem; + *index_len = cp - elem; + *type = cp+1; + *type_len = strlen(cp+1); + } + } + return 1; +} + + +int zebra_special_sort_fetch(ZebraHandle zh, zint sysno, ODR odr, + const char *elemsetname, + oid_value input_format, + oid_value *output_format, + char **rec_bufp, int *rec_lenp) +{ + const char *retrieval_index; + size_t retrieval_index_len; + const char *retrieval_type; + size_t retrieval_type_len; + char retrieval_index_cstr[256]; + int ord; + + /* only accept XML and SUTRS requests */ + if (input_format != VAL_TEXT_XML && input_format != VAL_SUTRS) + { + yaz_log(YLOG_WARN, "unsupported format for element set zebra::%s", + elemsetname); + *output_format = VAL_NONE; + return YAZ_BIB1_NO_SYNTAXES_AVAILABLE_FOR_THIS_REQUEST; + } + + if (!parse_zebra_elem(elemsetname, + &retrieval_index, &retrieval_index_len, + &retrieval_type, &retrieval_type_len)) + { + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; + } + + if (retrieval_type_len == 0) + return -1; /* must have a register type specified */ + if (!retrieval_index_len || + retrieval_index_len >= sizeof(retrieval_index_cstr)-1) + { + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; + } + + memcpy(retrieval_index_cstr, retrieval_index, retrieval_index_len); + retrieval_index_cstr[retrieval_index_len] = '\0'; + + ord = zebraExplain_lookup_attr_str(zh->reg->zei, + zinfo_index_category_sort, + retrieval_type[0], + retrieval_index_cstr); + if (ord == -1) + return -1; /* is not a sort index */ + else + { + char dst_buf[IT_MAX_WORD]; + char str[IT_MAX_WORD]; + int index_type; + const char *db = 0; + const char *string_index = 0; + WRBUF wrbuf = wrbuf_alloc(); + + zebra_sort_sysno(zh->reg->sort_index, sysno); + zebra_sort_type(zh->reg->sort_index, ord); + zebra_sort_read(zh->reg->sort_index, str); + + zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type, &db, &string_index); + + zebra_term_untrans(zh, index_type, dst_buf, str); + + + if (input_format == VAL_TEXT_XML) + { + *output_format = VAL_TEXT_XML; + wrbuf_printf(wrbuf, ZEBRA_XML_HEADER_STR + " sysno=\"" ZINT_FORMAT "\"" + " set=\"zebra::index%s/\">\n", + sysno, elemsetname); + + wrbuf_printf(wrbuf, " ", index_type); + wrbuf_xmlputs(wrbuf, dst_buf); + wrbuf_printf(wrbuf, "\n"); + wrbuf_printf(wrbuf, "\n"); + } + else if (input_format == VAL_SUTRS) + { + *output_format = VAL_SUTRS; + + wrbuf_printf(wrbuf, "%s %c %s\n", string_index, index_type, + dst_buf); + } + *rec_lenp = wrbuf_len(wrbuf); + *rec_bufp = odr_malloc(odr, *rec_lenp); + memcpy(*rec_bufp, wrbuf_buf(wrbuf), *rec_lenp); + wrbuf_destroy(wrbuf); + return 0; + } +} + +int zebra_special_index_fetch(ZebraHandle zh, zint sysno, ODR odr, + Record rec, + const char *elemsetname, + oid_value input_format, + oid_value *output_format, + char **rec_bufp, int *rec_lenp) +{ + const char *retrieval_index; + size_t retrieval_index_len; + const char *retrieval_type; + size_t retrieval_type_len; + zebra_rec_keys_t keys; + int ret_code = 0; + + /* set output variables before processing possible error states */ + /* *rec_lenp = 0; */ + + /* only accept XML and SUTRS requests */ + if (input_format != VAL_TEXT_XML && input_format != VAL_SUTRS) + { + yaz_log(YLOG_WARN, "unsupported format for element set zebra::%s", + elemsetname); + *output_format = VAL_NONE; + return YAZ_BIB1_NO_SYNTAXES_AVAILABLE_FOR_THIS_REQUEST; + } + + if (!parse_zebra_elem(elemsetname, + &retrieval_index, &retrieval_index_len, + &retrieval_type, &retrieval_type_len)) + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; + + if (retrieval_type_len != 0 && retrieval_type_len != 1) + { + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; + } + + if (retrieval_index_len) + { + char retrieval_index_cstr[256]; + + if (retrieval_index_len < sizeof(retrieval_index_cstr) -1) + { + memcpy(retrieval_index_cstr, retrieval_index, retrieval_index_len); + retrieval_index_cstr[retrieval_index_len] = '\0'; + + if (zebraExplain_lookup_attr_str(zh->reg->zei, + zinfo_index_category_index, + (retrieval_type_len == 0 ? -1 : + retrieval_type[0]), + retrieval_index_cstr) == -1) + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; + } + } + + keys = zebra_rec_keys_open(); + zebra_rec_keys_set_buf(keys, rec->info[recInfo_delKeys], + rec->size[recInfo_delKeys], 0); + + if (!zebra_rec_keys_rewind(keys)) + { + ret_code = + YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; + } + else + { + size_t slen; + const char *str; + struct it_key key_in; + WRBUF wrbuf = wrbuf_alloc(); + + if (input_format == VAL_TEXT_XML) + { + *output_format = VAL_TEXT_XML; + wrbuf_printf(wrbuf, ZEBRA_XML_HEADER_STR + " sysno=\"" ZINT_FORMAT "\"" + " set=\"zebra::index%s/\">\n", + sysno, elemsetname); + } + else if (input_format == VAL_SUTRS) + *output_format = VAL_SUTRS; + + while (zebra_rec_keys_read(keys, &str, &slen, &key_in)) + { + int i; + int ord = CAST_ZINT_TO_INT(key_in.mem[0]); + int index_type; + const char *db = 0; + const char *string_index = 0; + size_t string_index_len; + char dst_buf[IT_MAX_WORD]; + + zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type, &db, + &string_index); + string_index_len = strlen(string_index); + + /* process only if index is not defined, + or if defined and matching */ + if (retrieval_index == 0 + || (string_index_len == retrieval_index_len + && !memcmp(string_index, retrieval_index, + string_index_len))) + { + /* process only if type is not defined, or is matching */ + if (retrieval_type == 0 + || (retrieval_type_len == 1 + && retrieval_type[0] == index_type)) + { + zebra_term_untrans(zh, index_type, dst_buf, str); + if (strlen(dst_buf)) + { + if (input_format == VAL_TEXT_XML){ + wrbuf_printf(wrbuf, " ", + key_in.mem[key_in.len -1]); + + wrbuf_xmlputs(wrbuf, dst_buf); + wrbuf_printf(wrbuf, "\n"); + } + else if (input_format == VAL_SUTRS){ + wrbuf_printf(wrbuf, "%s ", string_index); + + wrbuf_printf(wrbuf, "%c", index_type); + + for (i = 1; i < key_in.len; i++) + wrbuf_printf(wrbuf, " " ZINT_FORMAT, + key_in.mem[i]); + + /* zebra_term_untrans(zh, index_type, dst_buf, str); */ + wrbuf_printf(wrbuf, " %s", dst_buf); + + wrbuf_printf(wrbuf, "\n"); + } + } + + } + } + } + if (input_format == VAL_TEXT_XML) + wrbuf_printf(wrbuf, "\n"); + *rec_lenp = wrbuf_len(wrbuf); + *rec_bufp = odr_malloc(odr, *rec_lenp); + memcpy(*rec_bufp, wrbuf_buf(wrbuf), *rec_lenp); + wrbuf_destroy(wrbuf); + } + zebra_rec_keys_close(keys); + return ret_code; } -static off_t record_ext_seek (void *fh, off_t offset) + +static void retrieve_puts_attr(WRBUF wrbuf, const char *name, + const char *value) { - struct fetch_control *fc = fh; - return lseek (fc->fd, offset + fc->record_offset, SEEK_SET); + if (value) + { + wrbuf_printf(wrbuf, " %s=\"", name); + wrbuf_xmlputs(wrbuf, value); + wrbuf_printf(wrbuf, "\""); + } } -static off_t record_ext_tell (void *fh) +static void retrieve_puts_attr_int(WRBUF wrbuf, const char *name, + const int value) { - struct fetch_control *fc = fh; - return lseek (fc->fd, 0, SEEK_CUR) - fc->record_offset; + wrbuf_printf(wrbuf, " %s=\"%i\"", name, value); } -static off_t record_int_seek (void *fh, off_t offset) +static void retrieve_puts_str(WRBUF wrbuf, const char *name, + const char *value) { - struct fetch_control *fc = fh; - return (off_t) (fc->record_int_pos = offset); + if (value) + wrbuf_printf(wrbuf, "%s %s\n", name, value); } -static off_t record_int_tell (void *fh) +static void retrieve_puts_int(WRBUF wrbuf, const char *name, + const int value) { - struct fetch_control *fc = fh; - return (off_t) fc->record_int_pos; + wrbuf_printf(wrbuf, "%s %i\n", name, value); } -static int record_int_read (void *fh, char *buf, size_t count) +int zebra_special_fetch(ZebraHandle zh, zint sysno, int score, ODR odr, + const char *elemsetname, + oid_value input_format, + oid_value *output_format, + char **rec_bufp, int *rec_lenp) { - struct fetch_control *fc = fh; - int l = fc->record_int_len - fc->record_int_pos; - if (l <= 0) + Record rec; + + /* set output variables before processing possible error states */ + /* *rec_lenp = 0; */ + + + + /* processing zebra::meta::sysno elemset without fetching binary data */ + if (elemsetname && 0 == strcmp(elemsetname, "meta::sysno")) + { + int ret = 0; + WRBUF wrbuf = wrbuf_alloc(); + if (input_format == VAL_SUTRS) + { + wrbuf_printf(wrbuf, ZINT_FORMAT, sysno); + *output_format = VAL_SUTRS; + } + else if (input_format == VAL_TEXT_XML) + { + wrbuf_printf(wrbuf, ZEBRA_XML_HEADER_STR + " sysno=\"" ZINT_FORMAT "\"/>\n", + sysno); + *output_format = VAL_TEXT_XML; + } + *rec_lenp = wrbuf_len(wrbuf); + if (*rec_lenp) + *rec_bufp = odr_strdup(odr, wrbuf_cstr(wrbuf)); + else + ret = YAZ_BIB1_NO_SYNTAXES_AVAILABLE_FOR_THIS_REQUEST; + wrbuf_destroy(wrbuf); + return ret; + } + + /* processing special elementsetname zebra::index:: for sort elements */ + if (elemsetname && 0 == strncmp(elemsetname, "index", 5)) + { + int ret = zebra_special_sort_fetch(zh, sysno, odr, + elemsetname + 5, + input_format, output_format, + rec_bufp, rec_lenp); + if (ret != -1) + return ret; + /* not a sort index so we continue to get the full record */ + } + + + /* fetching binary record up for all other display elementsets */ + rec = rec_get(zh->reg->records, sysno); + if (!rec) + { + yaz_log(YLOG_WARN, "rec_get fail on sysno=" ZINT_FORMAT, sysno); + return YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; + } + + /* processing special elementsetnames zebra::data */ + if (elemsetname && 0 == strcmp(elemsetname, "data")) + { + struct ZebraRecStream stream; + RecordAttr *recordAttr = rec_init_attr(zh->reg->zei, rec); + zebra_create_record_stream(zh, &rec, &stream); + *output_format = input_format; + *rec_lenp = recordAttr->recordSize; + *rec_bufp = (char *) odr_malloc(odr, *rec_lenp); + stream.readf(&stream, *rec_bufp, *rec_lenp); + stream.destroy(&stream); + rec_free(&rec); return 0; - l = (l < (int) count) ? l : count; - memcpy (buf, fc->record_int_buf + fc->record_int_pos, l); - fc->record_int_pos += l; - return l; + } + + /* only accept XML and SUTRS requests from now */ + if (input_format != VAL_TEXT_XML && input_format != VAL_SUTRS) + { + yaz_log(YLOG_WARN, "unsupported format for element set zebra::%s", + elemsetname); + return YAZ_BIB1_NO_SYNTAXES_AVAILABLE_FOR_THIS_REQUEST; + } + + + /* processing special elementsetnames zebra::meta:: */ + if (elemsetname && 0 == strcmp(elemsetname, "meta")) + { + int ret = 0; + WRBUF wrbuf = wrbuf_alloc(); + RecordAttr *recordAttr = rec_init_attr(zh->reg->zei, rec); + + if (input_format == VAL_TEXT_XML) + { + *output_format = VAL_TEXT_XML; + + wrbuf_printf(wrbuf, ZEBRA_XML_HEADER_STR + " sysno=\"" ZINT_FORMAT "\"", sysno); + retrieve_puts_attr(wrbuf, "base", rec->info[recInfo_databaseName]); + retrieve_puts_attr(wrbuf, "file", rec->info[recInfo_filename]); + retrieve_puts_attr(wrbuf, "type", rec->info[recInfo_fileType]); + if (score >= 0) + retrieve_puts_attr_int(wrbuf, "score", score); + + wrbuf_printf(wrbuf, + " rank=\"" ZINT_FORMAT "\"" + " size=\"%i\"" + " set=\"zebra::%s\"/>\n", + recordAttr->staticrank, + recordAttr->recordSize, + elemsetname); + } + else if (input_format == VAL_SUTRS) + { + *output_format = VAL_SUTRS; + wrbuf_printf(wrbuf, "sysno " ZINT_FORMAT "\n", sysno); + retrieve_puts_str(wrbuf, "base", rec->info[recInfo_databaseName]); + retrieve_puts_str(wrbuf, "file", rec->info[recInfo_filename]); + retrieve_puts_str(wrbuf, "type", rec->info[recInfo_fileType]); + if (score >= 0) + retrieve_puts_int(wrbuf, "score", score); + + wrbuf_printf(wrbuf, + "rank " ZINT_FORMAT "\n" + "size %i\n" + "set zebra::%s\n", + recordAttr->staticrank, + recordAttr->recordSize, + elemsetname); + } + *rec_lenp = wrbuf_len(wrbuf); + if (*rec_lenp) + *rec_bufp = odr_strdup(odr, wrbuf_cstr(wrbuf)); + else + ret = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; + + wrbuf_destroy(wrbuf); + rec_free(&rec); + return ret; + } + + /* processing special elementsetnames zebra::index:: */ + if (elemsetname && 0 == strncmp(elemsetname, "index", 5)) + { + int ret = zebra_special_index_fetch(zh, sysno, odr, rec, + elemsetname + 5, + input_format, output_format, + rec_bufp, rec_lenp); + + rec_free(&rec); + return ret; + } + + if (rec) + rec_free(&rec); + return YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_; } -int zebra_record_fetch (ZebraHandle zh, int sysno, int score, ODR stream, - oid_value input_format, Z_RecordComposition *comp, - oid_value *output_format, char **rec_bufp, - int *rec_lenp, char **basenamep) + +int zebra_record_fetch(ZebraHandle zh, zint sysno, int score, + zebra_snippets *hit_snippet, ODR odr, + oid_value input_format, Z_RecordComposition *comp, + oid_value *output_format, + char **rec_bufp, int *rec_lenp, char **basenamep, + char **addinfo) { Record rec; char *fname, *file_type, *basename; - RecType rt; - struct recRetrieveCtrl retrieveCtrl; - char subType[128]; - struct fetch_control fc; + const char *elemsetname; + struct ZebraRecStream stream; RecordAttr *recordAttr; + void *clientData; + int return_code = 0; + + *basenamep = 0; + *addinfo = 0; + elemsetname = yaz_get_esn(comp); - rec = rec_get (zh->records, sysno); + /* processing zebra special elementset names of form 'zebra:: */ + if (elemsetname && 0 == strncmp(elemsetname, "zebra::", 7)) + return zebra_special_fetch(zh, sysno, score, odr, + elemsetname + 7, + input_format, output_format, + rec_bufp, rec_lenp); + + + /* processing all other element set names */ + rec = rec_get(zh->reg->records, sysno); if (!rec) { - logf (LOG_DEBUG, "rec_get fail on sysno=%d", sysno); - return 14; + yaz_log(YLOG_WARN, "rec_get fail on sysno=" ZINT_FORMAT, sysno); + *basenamep = 0; + return YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; } - recordAttr = rec_init_attr (zh->zei, rec); + + + recordAttr = rec_init_attr(zh->reg->zei, rec); file_type = rec->info[recInfo_fileType]; fname = rec->info[recInfo_filename]; basename = rec->info[recInfo_databaseName]; - *basenamep = odr_malloc (stream, strlen(basename)+1); + *basenamep = (char *) odr_malloc (odr, strlen(basename)+1); strcpy (*basenamep, basename); - if (!(rt = recType_byName (zh->recTypes, file_type, subType))) - { - logf (LOG_WARN, "Retrieve: Cannot handle type %s", file_type); - return 14; - } - logf (LOG_DEBUG, "retrieve localno=%d score=%d", sysno, score); - retrieveCtrl.fh = &fc; - fc.fd = -1; - if (rec->size[recInfo_storeData] > 0) - { - retrieveCtrl.readf = record_int_read; - retrieveCtrl.seekf = record_int_seek; - retrieveCtrl.tellf = record_int_tell; - fc.record_int_len = rec->size[recInfo_storeData]; - fc.record_int_buf = rec->info[recInfo_storeData]; - fc.record_int_pos = 0; - logf (LOG_DEBUG, "Internal retrieve. %d bytes", fc.record_int_len); - } -#if ZEBRASDR - else if (*fname == '%') - { - ZebraSdrHandle h; - int segment = 0, r; - char *cp, xname[128]; - unsigned char *buf; - - logf (LOG_DEBUG, "SDR"); - strcpy (xname, fname+1); - if ((cp = strrchr (xname, '.'))) - { - *cp++ = 0; - segment = atoi(cp); - } - h = zebraSdr_open (xname); - if (!h) - { - logf (LOG_WARN, "sdr open %s", xname); - return 0; - } - if (zebraSdr_segment (h, &segment) < 0) - { - logf (LOG_WARN, "zebraSdr_segment fail segment=%d", - segment); - rec_rm (&rec); - return 14; - } - r = zebraSdr_read (h, &buf); - if (r < 1) - { - logf (LOG_WARN, "zebraSdr_read fail segment=%d", - segment); - rec_rm (&rec); - return 14; - } - zebraSdr_close (h); - - fc.record_int_len = recordAttr->recordSize; - fc.record_int_buf = buf + recordAttr->recordOffset; - fc.record_int_pos = 0; - - logf (LOG_LOG, "segment = %d len=%d off=%d", - segment, - recordAttr->recordSize, - recordAttr->recordOffset); - if (fc.record_int_len > 180) - { - logf (LOG_LOG, "%.70s", fc.record_int_buf); - logf (LOG_LOG, "%.70s", fc.record_int_buf + - (fc.record_int_len - 70)); - } - else - logf (LOG_LOG, "%.*s", - fc.record_int_len, fc.record_int_buf); - - /* the following two lines makes rec_rm delete buf */ - rec->size[recInfo_storeData] = r; - rec->info[recInfo_storeData] = buf; - - retrieveCtrl.readf = record_int_read; - retrieveCtrl.seekf = record_int_seek; - retrieveCtrl.tellf = record_int_tell; - } -#endif - else + yaz_log(YLOG_DEBUG, "retrieve localno=" ZINT_FORMAT " score=%d", + sysno, score); + + return_code = zebra_create_record_stream(zh, &rec, &stream); + + if (rec) { - if ((fc.fd = open (fname, O_BINARY|O_RDONLY)) == -1) + zebra_snippets *snippet; + zebra_rec_keys_t reckeys = zebra_rec_keys_open(); + RecType rt; + struct recRetrieveCtrl retrieveCtrl; + + retrieveCtrl.stream = &stream; + retrieveCtrl.fname = fname; + retrieveCtrl.localno = sysno; + retrieveCtrl.staticrank = recordAttr->staticrank; + retrieveCtrl.score = score; + retrieveCtrl.recordSize = recordAttr->recordSize; + retrieveCtrl.odr = odr; + retrieveCtrl.input_format = retrieveCtrl.output_format = input_format; + retrieveCtrl.comp = comp; + retrieveCtrl.encoding = zh->record_encoding; + retrieveCtrl.diagnostic = 0; + retrieveCtrl.addinfo = 0; + retrieveCtrl.dh = zh->reg->dh; + retrieveCtrl.res = zh->res; + retrieveCtrl.rec_buf = 0; + retrieveCtrl.rec_len = -1; + retrieveCtrl.hit_snippet = hit_snippet; + retrieveCtrl.doc_snippet = zebra_snippets_create(); + + zebra_rec_keys_set_buf(reckeys, + rec->info[recInfo_delKeys], + rec->size[recInfo_delKeys], + 0); + zebra_rec_keys_to_snippets(zh, reckeys, retrieveCtrl.doc_snippet); + zebra_rec_keys_close(reckeys); + +#if 0 + /* for debugging purposes */ + yaz_log(YLOG_LOG, "DOC SNIPPET:"); + zebra_snippets_log(retrieveCtrl.doc_snippet, YLOG_LOG); + yaz_log(YLOG_LOG, "HIT SNIPPET:"); + zebra_snippets_log(retrieveCtrl.hit_snippet, YLOG_LOG); +#endif + snippet = zebra_snippets_window(retrieveCtrl.doc_snippet, + retrieveCtrl.hit_snippet, + 10); +#if 0 + /* for debugging purposes */ + yaz_log(YLOG_LOG, "WINDOW SNIPPET:"); + zebra_snippets_log(snippet, YLOG_LOG); +#endif + + if (!(rt = recType_byName(zh->reg->recTypes, zh->res, + file_type, &clientData))) + { + char addinfo_str[100]; + + sprintf(addinfo_str, "Could not handle record type %.40s", + file_type); + + *addinfo = odr_strdup(odr, addinfo_str); + return_code = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS; + } + else { - logf (LOG_WARN|LOG_ERRNO, "Retrieve fail; missing file: %s", - fname); - rec_rm (&rec); - return 14; + (*rt->retrieve)(clientData, &retrieveCtrl); + return_code = retrieveCtrl.diagnostic; + + *output_format = retrieveCtrl.output_format; + *rec_bufp = (char *) retrieveCtrl.rec_buf; + *rec_lenp = retrieveCtrl.rec_len; + *addinfo = retrieveCtrl.addinfo; } - fc.record_offset = recordAttr->recordOffset; - - retrieveCtrl.readf = record_ext_read; - retrieveCtrl.seekf = record_ext_seek; - retrieveCtrl.tellf = record_ext_tell; - - record_ext_seek (retrieveCtrl.fh, 0); - } - retrieveCtrl.subType = subType; - retrieveCtrl.localno = sysno; - retrieveCtrl.score = score; - retrieveCtrl.recordSize = recordAttr->recordSize; - retrieveCtrl.odr = stream; - retrieveCtrl.input_format = retrieveCtrl.output_format = input_format; - retrieveCtrl.comp = comp; - retrieveCtrl.diagnostic = 0; - retrieveCtrl.dh = zh->dh; - retrieveCtrl.res = zh->res; - (*rt->retrieve)(&retrieveCtrl); - *output_format = retrieveCtrl.output_format; - *rec_bufp = retrieveCtrl.rec_buf; - *rec_lenp = retrieveCtrl.rec_len; - if (fc.fd != -1) - close (fc.fd); - rec_rm (&rec); - - return retrieveCtrl.diagnostic; + + zebra_snippets_destroy(snippet); + zebra_snippets_destroy(retrieveCtrl.doc_snippet); + + stream.destroy(&stream); + rec_free(&rec); + } + + return return_code; } + +/* + * Local variables: + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */ +