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