index/zlogs.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zlogs.c,v $
   7  * Revision 1.6  1997-09-29 09:06:41  adam
   8  * Removed static var to make this module thread safe.
   9  *
  10  * Revision 1.5  1997/04/30 08:56:07  quinn
  11  * null
  12  *
  13  * Revision 1.4  1996/10/08  09:41:25  quinn
  14  * Fixed diagnostic.
  15  *
  16  * Revision 1.3  1996/03/20  09:36:40  adam
  17  * Function dict_lookup_grep got extra parameter, init_pos, which marks
  18  * from which position in pattern approximate pattern matching should occur.
  19  * Approximate pattern matching is used in relevance=re-2.
  20  *
  21  * Revision 1.2  1996/01/03  16:22:11  quinn
  22  * operator->roperator
  23  *
  24  * Revision 1.1  1995/11/16  17:00:55  adam
  25  * Better logging of rpn query.
  26  *
  27  */
  28 #include <stdio.h>
  29 #include <assert.h>
  30
  31 #include "zserver.h"
  32
  33 static void attrStr (int type, int value, enum oid_value ast, char *str)
  34 {
  35     *str = '\0';
  36     switch (ast)
  37     {
  38     case VAL_BIB1:
  39     case VAL_EXP1:
  40     case VAL_GILS:
  41         switch (type)
  42         {
  43         case 1:
  44             sprintf (str, "use");
  45             break;
  46         case 2:
  47             switch (value)
  48             {
  49             case 1:
  50                 sprintf (str, "relation=Less than");
  51                 break;
  52             case 2:
  53                 sprintf (str, "relation=Less than or equal");
  54                 break;
  55             case 3:
  56                 sprintf (str, "relation=Equal");
  57                 break;
  58             case 4:
  59                 sprintf (str, "relation=Greater or equal");
  60                 break;
  61             case 5:
  62                 sprintf (str, "relation=Greater than");
  63                 break;
  64             case 6:
  65                 sprintf (str, "relation=Not equal");
  66                 break;
  67             case 100:
  68                 sprintf (str, "relation=Phonetic");
  69                 break;
  70             case 101:
  71                 sprintf (str, "relation=Stem");
  72                 break;
  73             case 102:
  74                 sprintf (str, "relation=Relevance");
  75                 break;
  76             case 103:
  77                 sprintf (str, "relation=AlwaysMatches");
  78                 break;
  79             default:
  80                 sprintf (str, "relation");
  81             }
  82             break;
  83         case 3:
  84             switch (value)
  85             {
  86             case 1:
  87                 sprintf (str, "position=First in field");
  88                 break;
  89             case 2:
  90                 sprintf (str, "position=First in any subfield");
  91                 break;
  92             case 3:
  93                 sprintf (str, "position=Any position in field");
  94                 break;
  95             default:
  96                 sprintf (str, "position");
  97             }
  98             break;
  99         case 4:
 100             switch (value)
 101             {
 102             case 1:
 103                 sprintf (str, "structure=Phrase");
 104                 break;
 105             case 2:
 106                 sprintf (str, "structure=Word");
 107                 break;
 108             case 3:
 109                 sprintf (str, "structure=Key");
 110                 break;
 111             case 4:
 112                 sprintf (str, "structure=Year");
 113                 break;
 114             case 5:
 115                 sprintf (str, "structure=Date");
 116                 break;
 117             case 6:
 118                 sprintf (str, "structure=Word list");
 119                 break;
 120             case 100:
 121                 sprintf (str, "structure=Date (un)");
 122                 break;
 123             case 101:
 124                 sprintf (str, "structure=Name (norm)");
 125                 break;
 126             case 102:
 127                 sprintf (str, "structure=Name (un)");
 128                 break;
 129             case 103:
 130                 sprintf (str, "structure=Structure");
 131                 break;
 132             case 104:
 133                 sprintf (str, "structure=urx");
 134                 break;
 135             case 105:
 136                 sprintf (str, "structure=free-form-text");
 137                 break;
 138             case 106:
 139                 sprintf (str, "structure=document-text");
 140                 break;
 141             case 107:
 142                 sprintf (str, "structure=local-number");
 143                 break;
 144             case 108:
 145                 sprintf (str, "structure=string");
 146                 break;
 147             case 109:
 148                 sprintf (str, "structure=numeric string");
 149                 break;
 150             default:
 151                 sprintf (str, "structure");
 152             }
 153             break;
 154         case 5:
 155             switch (value)
 156             {
 157             case 1:
 158                 sprintf (str, "truncation=Right");
 159                 break;
 160             case 2:
 161                 sprintf (str, "truncation=Left");
 162                 break;
 163             case 3:
 164                 sprintf (str, "truncation=Left&right");
 165                 break;
 166             case 100:
 167                 sprintf (str, "truncation=Do not truncate");
 168                 break;
 169             case 101:
 170                 sprintf (str, "truncation=Process #");
 171                 break;
 172             case 102:
 173                 sprintf (str, "truncation=re-1");
 174                 break;
 175             case 103:
 176                 sprintf (str, "truncation=re-2");
 177                 break;
 178             default:
 179                 sprintf (str, "truncation");
 180             }
 181             break;
 182         case 6:
 183             switch (value)
 184             {
 185             case 1:
 186                 sprintf (str, "completeness=Incomplete subfield");
 187                 break;
 188             case 2:
 189                 sprintf (str, "completeness=Complete subfield");
 190                 break;
 191             case 3:
 192                 sprintf (str, "completeness=Complete field");
 193                 break;
 194             default:
 195                 sprintf (str, "completeness");
 196             }
 197             break;
 198         }
 199         break;
 200     default:
 201         break;
 202     }
 203     if (*str)
 204         sprintf (str + strlen(str), " (%d=%d)", type, value);
 205     else
 206         sprintf (str, "%d=%d", type, value);
 207 }
 208
 209 /*
 210  * zlog_attributes: print attributes of term
 211  */
 212 static void zlog_attributes (Z_AttributesPlusTerm *t, int level,
 213                              enum oid_value ast)
 214 {
 215     int of, i;
 216     char str[80];
 217     for (of = 0; of < t->num_attributes; of++)
 218     {
 219         Z_AttributeElement *element;
 220         element = t->attributeList[of];
 221
 222         switch (element->which)
 223         {
 224         case Z_AttributeValue_numeric:
 225             attrStr (*element->attributeType,
 226                      *element->value.numeric, ast, str);
 227             logf (LOG_LOG, "%*.s %s", level, "", str);
 228             break;
 229         case Z_AttributeValue_complex:
 230             logf (LOG_LOG, "%*.s attributeType=%d complex", level, "",
 231                   *element->attributeType);
 232             for (i = 0; i<element->value.complex->num_list; i++)
 233             {
 234                 if (element->value.complex->list[i]->which ==
 235                     Z_StringOrNumeric_string)
 236                     logf (LOG_LOG, "%*.s  string: '%s'", level, "",
 237                           element->value.complex->list[i]->u.string);
 238                 else if (element->value.complex->list[i]->which ==
 239                          Z_StringOrNumeric_numeric)
 240                     logf (LOG_LOG, "%*.s  numeric: '%d'", level, "",
 241                           *element->value.complex->list[i]->u.numeric);
 242             }
 243             break;
 244         default:
 245             logf (LOG_LOG, "%.*s attribute unknown", level, "");
 246         }
 247     }
 248 }
 249
 250 static void zlog_structure (Z_RPNStructure *zs, int level, enum oid_value ast)
 251 {
 252     if (zs->which == Z_RPNStructure_complex)
 253     {
 254         switch (zs->u.complex->roperator->which)
 255         {
 256         case Z_Operator_and:
 257             logf (LOG_LOG, "%*.s and", level, "");
 258             break;
 259         case Z_Operator_or:
 260             logf (LOG_LOG, "%*.s or", level, "");
 261             break;
 262         case Z_Operator_and_not:
 263             logf (LOG_LOG, "%*.s and-not", level, "");
 264             break;
 265         default:
 266             logf (LOG_LOG, "%*.s unknown complex", level, "");
 267             return;
 268         }
 269         zlog_structure (zs->u.complex->s1, level+2, ast);
 270         zlog_structure (zs->u.complex->s2, level+2, ast);
 271     }
 272     else if (zs->which == Z_RPNStructure_simple)
 273     {
 274         if (zs->u.simple->which == Z_Operand_APT)
 275         {
 276             Z_AttributesPlusTerm *zapt = zs->u.simple->u.attributesPlusTerm;
 277
 278             if (zapt->term->which == Z_Term_general)
 279             {
 280                 logf (LOG_LOG, "%*.s term '%.*s' (general)", level, "",
 281                       zapt->term->u.general->len, zapt->term->u.general->buf);
 282             }
 283             else
 284             {
 285                 logf (LOG_LOG, "%*.s term (not general)", level, "");
 286             }
 287             zlog_attributes (zapt, level+2, ast);
 288         }
 289         else if (zs->u.simple->which == Z_Operand_resultSetId)
 290         {
 291             logf (LOG_LOG, "%*.s set '%s'", level, "",
 292                   zs->u.simple->u.resultSetId);
 293         }
 294         else
 295             logf (LOG_LOG, "%*.s unknown simple structure", level, "");
 296     }
 297     else
 298         logf (LOG_LOG, "%*.s unknown structure", level, "");
 299 }
 300
 301 void zlog_rpn (Z_RPNQuery *rpn)
 302 {
 303     oident *attrset = oid_getentbyoid (rpn->attributeSetId);
 304     enum oid_value ast;
 305
 306     ast = attrset->value;
 307     logf (LOG_LOG, "RPN query. Type: %s", attrset->desc);
 308     zlog_structure (rpn->RPNStructure, 0, ast);
 309 }