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