From e207755675f8dbf552f1e0696077594e7fa68190 Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Mon, 16 Nov 1998 16:02:32 +0000 Subject: [PATCH] Added loggin utilies, log_rpn_query and log_scan_term. These used to be part of Zebra. --- include/logrpn.h | 30 +++++ server/seshigh.c | 50 ++++++-- util/Makefile.in | 7 +- util/logrpn.c | 366 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 438 insertions(+), 15 deletions(-) create mode 100644 include/logrpn.h create mode 100644 util/logrpn.c diff --git a/include/logrpn.h b/include/logrpn.h new file mode 100644 index 0000000..a77985c --- /dev/null +++ b/include/logrpn.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 1997-1998, Index Data. + * See the file LICENSE for details. + * Sebastian Hammer, Adam Dickmeiss + * + * $Log: logrpn.h,v $ + * Revision 1.1 1998-11-16 16:02:32 adam + * Added loggin utilies, log_rpn_query and log_scan_term. These used + * to be part of Zebra. + * + */ + +#ifndef LOG_RPN_H +#define LOG_RPN_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +YAZ_EXPORT void log_rpn_query (Z_RPNQuery *rpn); +YAZ_EXPORT void log_scan_term (Z_AttributesPlusTerm *zapt, oid_value ast); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/server/seshigh.c b/server/seshigh.c index 9b4792e..7683043 100644 --- a/server/seshigh.c +++ b/server/seshigh.c @@ -4,7 +4,11 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: seshigh.c,v $ - * Revision 1.83 1998-11-03 10:09:36 adam + * Revision 1.84 1998-11-16 16:02:32 adam + * Added loggin utilies, log_rpn_query and log_scan_term. These used + * to be part of Zebra. + * + * Revision 1.83 1998/11/03 10:09:36 adam * Fixed bug regarding YC. * * Revision 1.82 1998/10/20 14:00:30 quinn @@ -305,6 +309,7 @@ #include #include #include +#include #include #include @@ -1007,9 +1012,12 @@ static Z_Records *pack_records(association *a, char *setname, int start, { int oid[OID_SIZE]; int recno, total_length = 0, toget = *num, dumped_records = 0; - Z_Records *records = (Z_Records *)odr_malloc (a->encode, sizeof(*records)); - Z_NamePlusRecordList *reclist = (Z_NamePlusRecordList *)odr_malloc (a->encode, sizeof(*reclist)); - Z_NamePlusRecord **list = (Z_NamePlusRecord **)odr_malloc (a->encode, sizeof(*list) * toget); + Z_Records *records = + (Z_Records *) odr_malloc (a->encode, sizeof(*records)); + Z_NamePlusRecordList *reclist = + (Z_NamePlusRecordList *) odr_malloc (a->encode, sizeof(*reclist)); + Z_NamePlusRecord **list = + (Z_NamePlusRecord **) odr_malloc (a->encode, sizeof(*list) * toget); oident recform; records->which = Z_Records_DBOSD; @@ -1020,7 +1028,7 @@ static Z_Records *pack_records(association *a, char *setname, int start, *num = 0; *next = 0; - logf(LOG_DEBUG, "Request to pack %d+%d", start, toget); + logf(LOG_LOG, "Request to pack %d+%d", start, toget); logf(LOG_DEBUG, "pms=%d, mrs=%d", a->preferredMessageSize, a->maximumRecordSize); for (recno = start; reclist->num_records < toget; recno++) @@ -1189,14 +1197,28 @@ static Z_APDU *process_searchRequest(association *assoc, request *reqb, int *fd) { Z_SearchRequest *req = reqb->request->u.searchRequest; - bend_search_rr *bsrr = (bend_search_rr *)nmem_malloc (reqb->request_mem, sizeof(*bsrr)); - + bend_search_rr *bsrr = + (bend_search_rr *)nmem_malloc (reqb->request_mem, sizeof(*bsrr)); + logf(LOG_LOG, "Got SearchRequest."); save_referenceId (reqb, req->referenceId); /* store ref id in request */ bsrr->fd = fd; bsrr->request = reqb; bsrr->association = assoc; + + logf (LOG_LOG, "ResultSet '%s'", req->resultSetName); + if (req->databaseNames) + { + int i; + for (i = 0; i < req->num_databaseNames; i++) + logf (LOG_LOG, "Database '%s'", req->databaseNames[i]); + } + switch (req->query->which) + { + case Z_Query_type_1: case Z_Query_type_101: + log_rpn_query (req->query->u.type_1); + } if (assoc->bend_search) { bsrr->setname = req->resultSetName; @@ -1209,7 +1231,8 @@ static Z_APDU *process_searchRequest(association *assoc, request *reqb, bsrr->errcode = 0; bsrr->hits = 0; bsrr->errstring = NULL; - ((int (*)(void *, bend_search_rr *))(assoc->bend_search))(assoc->backend, bsrr); + ((int (*)(void *, bend_search_rr *))(assoc->bend_search)) + (assoc->backend, bsrr); if (!bsrr->request) return 0; } @@ -1468,10 +1491,13 @@ static Z_APDU *process_scanRequest(association *assoc, request *reqb, int *fd) diagrecs_p = diagrecs(assoc, 205, 0); else { - if (req->termListAndStartPoint->term->which == Z_Term_general) - logf(LOG_DEBUG, " term: '%.*s'", - req->termListAndStartPoint->term->u.general->len, - req->termListAndStartPoint->term->u.general->buf); + if (req->databaseNames) + { + int i; + for (i = 0; i < req->num_databaseNames; i++) + logf (LOG_LOG, "Database '%s'", req->databaseNames[i]); + } + log_scan_term (req->termListAndStartPoint, attset->value); srq.num_bases = req->num_databaseNames; srq.basenames = req->databaseNames; srq.num_entries = *req->numberOfTermsRequested; diff --git a/util/Makefile.in b/util/Makefile.in index 223a6cb..e8d2cbb 100644 --- a/util/Makefile.in +++ b/util/Makefile.in @@ -1,7 +1,7 @@ -# Copyright (C) 1994-1997, Index Data I/S +# Copyright (C) 1994-1998, Index Data # All rights reserved. # Sebastian Hammer, Adam Dickmeiss -# $Id: Makefile.in,v 1.3 1998-10-28 15:10:12 adam Exp $ +# $Id: Makefile.in,v 1.4 1998-11-16 16:02:34 adam Exp $ SHELL=/bin/sh @@ -17,7 +17,8 @@ LIBDIR=../lib DEFS=$(INCLUDE) $(CDEFS) LIB=$(LIBDIR)/libutil.a PO = options.o log.o marcdisp.o yaz-ccl.o pquery.o oid.o wrbuf.o nmemsdup.o \ - xmalloc.o readconf.o tpath.o nmem.o yaz-util.o atoin.o # dmalloc.o + xmalloc.o readconf.o tpath.o nmem.o yaz-util.o atoin.o \ + logrpn.o # dmalloc.o all: $(LIB) marcdump diff --git a/util/logrpn.c b/util/logrpn.c new file mode 100644 index 0000000..16af8ba --- /dev/null +++ b/util/logrpn.c @@ -0,0 +1,366 @@ +/* + * Copyright (C) 1995-1998, Index Data + * All rights reserved. + * Sebastian Hammer, Adam Dickmeiss + * + * $Log: logrpn.c,v $ + * Revision 1.1 1998-11-16 16:02:35 adam + * Added loggin utilies, log_rpn_query and log_scan_term. These used + * to be part of Zebra. + * + * + * + * Old logs from zlogs.c: + * + * Revision 1.9 1998/10/13 20:36:02 adam + * Changed "indent" format string in log messages. + * + * Revision 1.8 1998/04/02 14:35:29 adam + * First version of Zebra that works with compiled ASN.1. + * + * Revision 1.7 1998/01/29 13:40:11 adam + * Better logging for scan service. + * + * Revision 1.6 1997/09/29 09:06:41 adam + * Removed static var to make this module thread safe. + * + * Revision 1.5 1997/04/30 08:56:07 quinn + * null + * + * Revision 1.4 1996/10/08 09:41:25 quinn + * Fixed diagnostic. + * + * Revision 1.3 1996/03/20 09:36:40 adam + * Function dict_lookup_grep got extra parameter, init_pos, which marks + * from which position in pattern approximate pattern matching should occur. + * Approximate pattern matching is used in relevance=re-2. + * + * Revision 1.2 1996/01/03 16:22:11 quinn + * operator->roperator + * + * Revision 1.1 1995/11/16 17:00:55 adam + * Better logging of rpn query. + * + */ +#include +#include + +#include +#include + +static void attrStr (int type, int value, enum oid_value ast, char *str) +{ + *str = '\0'; + switch (ast) + { + case VAL_BIB1: + case VAL_EXP1: + case VAL_GILS: + switch (type) + { + case 1: + sprintf (str, "use"); + break; + case 2: + switch (value) + { + case 1: + sprintf (str, "relation=Less than"); + break; + case 2: + sprintf (str, "relation=Less than or equal"); + break; + case 3: + sprintf (str, "relation=Equal"); + break; + case 4: + sprintf (str, "relation=Greater or equal"); + break; + case 5: + sprintf (str, "relation=Greater than"); + break; + case 6: + sprintf (str, "relation=Not equal"); + break; + case 100: + sprintf (str, "relation=Phonetic"); + break; + case 101: + sprintf (str, "relation=Stem"); + break; + case 102: + sprintf (str, "relation=Relevance"); + break; + case 103: + sprintf (str, "relation=AlwaysMatches"); + break; + default: + sprintf (str, "relation"); + } + break; + case 3: + switch (value) + { + case 1: + sprintf (str, "position=First in field"); + break; + case 2: + sprintf (str, "position=First in any subfield"); + break; + case 3: + sprintf (str, "position=Any position in field"); + break; + default: + sprintf (str, "position"); + } + break; + case 4: + switch (value) + { + case 1: + sprintf (str, "structure=Phrase"); + break; + case 2: + sprintf (str, "structure=Word"); + break; + case 3: + sprintf (str, "structure=Key"); + break; + case 4: + sprintf (str, "structure=Year"); + break; + case 5: + sprintf (str, "structure=Date"); + break; + case 6: + sprintf (str, "structure=Word list"); + break; + case 100: + sprintf (str, "structure=Date (un)"); + break; + case 101: + sprintf (str, "structure=Name (norm)"); + break; + case 102: + sprintf (str, "structure=Name (un)"); + break; + case 103: + sprintf (str, "structure=Structure"); + break; + case 104: + sprintf (str, "structure=urx"); + break; + case 105: + sprintf (str, "structure=free-form-text"); + break; + case 106: + sprintf (str, "structure=document-text"); + break; + case 107: + sprintf (str, "structure=local-number"); + break; + case 108: + sprintf (str, "structure=string"); + break; + case 109: + sprintf (str, "structure=numeric string"); + break; + default: + sprintf (str, "structure"); + } + break; + case 5: + switch (value) + { + case 1: + sprintf (str, "truncation=Right"); + break; + case 2: + sprintf (str, "truncation=Left"); + break; + case 3: + sprintf (str, "truncation=Left&right"); + break; + case 100: + sprintf (str, "truncation=Do not truncate"); + break; + case 101: + sprintf (str, "truncation=Process #"); + break; + case 102: + sprintf (str, "truncation=re-1"); + break; + case 103: + sprintf (str, "truncation=re-2"); + break; + default: + sprintf (str, "truncation"); + } + break; + case 6: + switch (value) + { + case 1: + sprintf (str, "completeness=Incomplete subfield"); + break; + case 2: + sprintf (str, "completeness=Complete subfield"); + break; + case 3: + sprintf (str, "completeness=Complete field"); + break; + default: + sprintf (str, "completeness"); + } + break; + } + break; + default: + break; + } + if (*str) + sprintf (str + strlen(str), " (%d=%d)", type, value); + else + sprintf (str, "%d=%d", type, value); +} + +/* + * zlog_attributes: print attributes of term + */ +static void zlog_attributes (Z_AttributesPlusTerm *t, int level, + enum oid_value ast) +{ + int of, i; + char str[80]; +#ifdef ASN_COMPILED + int num_attributes = t->attributes->num_attributes; +#else + int num_attributes = t->num_attributes; +#endif + + for (of = 0; of < num_attributes; of++) + { + const char *attset_name = ""; + Z_AttributeElement *element; +#ifdef ASN_COMPILED + element = t->attributes->attributes[of]; +#else + element = t->attributeList[of]; +#endif + if (element->attributeSet) + { + oident *attrset; + attrset = oid_getentbyoid (element->attributeSet); + attset_name = attrset->desc; + } + switch (element->which) + { + case Z_AttributeValue_numeric: + attrStr (*element->attributeType, + *element->value.numeric, ast, str); + logf (LOG_LOG, "%*.0s%s %s", level, "", attset_name, str); + break; + case Z_AttributeValue_complex: + logf (LOG_LOG, "%*.0s%s attributeType=%d complex", + level, "", attset_name, *element->attributeType); + for (i = 0; ivalue.complex->num_list; i++) + { + if (element->value.complex->list[i]->which == + Z_StringOrNumeric_string) + logf (LOG_LOG, "%*.0s string: '%s'", level, "", + element->value.complex->list[i]->u.string); + else if (element->value.complex->list[i]->which == + Z_StringOrNumeric_numeric) + logf (LOG_LOG, "%*.0s numeric: '%d'", level, "", + *element->value.complex->list[i]->u.numeric); + } + break; + default: + logf (LOG_LOG, "%.*s%s attribute unknown", + level, "", attset_name); + } + } +} + +static void zlog_structure (Z_RPNStructure *zs, int level, enum oid_value ast) +{ + if (zs->which == Z_RPNStructure_complex) + { + switch (zs->u.complex->roperator->which) + { + case Z_Operator_and: + logf (LOG_LOG, "%*.0s and", level, ""); + break; + case Z_Operator_or: + logf (LOG_LOG, "%*.0s or", level, ""); + break; + case Z_Operator_and_not: + logf (LOG_LOG, "%*.0s and-not", level, ""); + break; + default: + logf (LOG_LOG, "%*.0s unknown complex", level, ""); + return; + } + zlog_structure (zs->u.complex->s1, level+2, ast); + zlog_structure (zs->u.complex->s2, level+2, ast); + } + else if (zs->which == Z_RPNStructure_simple) + { + if (zs->u.simple->which == Z_Operand_APT) + { + Z_AttributesPlusTerm *zapt = zs->u.simple->u.attributesPlusTerm; + + if (zapt->term->which == Z_Term_general) + { + logf (LOG_LOG, "%*.0s term '%.*s' (general)", level, "", + zapt->term->u.general->len, zapt->term->u.general->buf); + } + else + { + logf (LOG_LOG, "%*.0s term (not general)", level, ""); + } + zlog_attributes (zapt, level+2, ast); + } + else if (zs->u.simple->which == Z_Operand_resultSetId) + { + logf (LOG_LOG, "%*.0s set '%s'", level, "", + zs->u.simple->u.resultSetId); + } + else + logf (LOG_LOG, "%*.0s unknown simple structure", level, ""); + } + else + logf (LOG_LOG, "%*.0s unknown structure", level, ""); +} + +void log_rpn_query (Z_RPNQuery *rpn) +{ + oident *attrset; + enum oid_value ast; + + attrset = oid_getentbyoid (rpn->attributeSetId); + if (attrset) + { + ast = attrset->value; + logf (LOG_LOG, "RPN query. Type: %s", attrset->desc); + } + else + { + ast = VAL_NONE; + logf (LOG_LOG, "RPN query. Unknown type"); + } + zlog_structure (rpn->RPNStructure, 0, ast); +} + +void log_scan_term (Z_AttributesPlusTerm *zapt, oid_value ast) +{ + int level = 0; + if (zapt->term->which == Z_Term_general) + { + logf (LOG_LOG, "%*.0s term '%.*s' (general)", level, "", + zapt->term->u.general->len, zapt->term->u.general->buf); + } + else + logf (LOG_LOG, "%*.0s term (not general)", level, ""); + zlog_attributes (zapt, level+2, ast); +} -- 1.7.10.4