zutil/pquery.c

   1 /*
   2  * Copyright (c) 1995-2002, Index Data.
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: pquery.c,v 1.16 2002-07-25 12:48:39 adam Exp $
   6  */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <ctype.h>
  12
  13 #include <yaz/proto.h>
  14 #include <yaz/oid.h>
  15 #include <yaz/pquery.h>
  16
  17 static oid_value p_query_dfset = VAL_NONE;
  18
  19 struct lex_info {
  20     const char *query_buf;
  21     const char *lex_buf;
  22     size_t lex_len;
  23     int query_look;
  24     char *left_sep;
  25     char *right_sep;
  26     int escape_char;
  27     int term_type;
  28 };
  29
  30 static Z_RPNStructure *rpn_structure (struct lex_info *li, ODR o, oid_proto,
  31                                       int num_attr, int max_attr,
  32                                       int *attr_list, char **attr_clist,
  33                                       oid_value *attr_set);
  34
  35 static enum oid_value query_oid_getvalbyname (struct lex_info *li)
  36 {
  37     enum oid_value value;
  38     char buf[32];
  39
  40     if (li->lex_len > 31)
  41         return VAL_NONE;
  42     memcpy (buf, li->lex_buf, li->lex_len);
  43     buf[li->lex_len] = '\0';
  44     value = oid_getvalbyname (buf);
  45     return value;
  46 }
  47
  48 static int compare_term (struct lex_info *li, const char *src, size_t off)
  49 {
  50     size_t len=strlen(src);
  51
  52     if (li->lex_len == len+off && !memcmp (li->lex_buf+off, src, len-off))
  53         return 1;
  54     return 0;
  55 }
  56
  57 static int query_token (struct lex_info *li)
  58 {
  59     int sep_char = ' ';
  60     const char *sep_match;
  61     const char **qptr = &li->query_buf;
  62
  63     while (**qptr == ' ')
  64         (*qptr)++;
  65     if (**qptr == '\0')
  66         return 0;
  67     li->lex_len = 0;
  68     if ((sep_match = strchr (li->left_sep, **qptr)))
  69     {
  70         sep_char = li->right_sep[sep_match - li->left_sep];
  71         ++(*qptr);
  72     }
  73     li->lex_buf = *qptr;
  74
  75     if (**qptr == li->escape_char && isdigit ((*qptr)[1]))
  76     {
  77         ++(li->lex_len);
  78         ++(*qptr);
  79         return 'l';
  80     }
  81     while (**qptr && **qptr != sep_char)
  82     {
  83         if (**qptr == '\\')
  84         {
  85             ++(li->lex_len);
  86             ++(*qptr);
  87         }
  88         ++(li->lex_len);
  89         ++(*qptr);
  90     }
  91     if (**qptr)
  92         ++(*qptr);
  93     if (sep_char == ' ' &&
  94         li->lex_len >= 1 && li->lex_buf[0] == li->escape_char)
  95     {
  96         if (compare_term (li, "and", 1))
  97             return 'a';
  98         if (compare_term (li, "or", 1))
  99             return 'o';
 100         if (compare_term (li, "not", 1))
 101             return 'n';
 102         if (compare_term (li, "attr", 1))
 103             return 'l';
 104         if (compare_term (li, "set", 1))
 105             return 's';
 106         if (compare_term (li, "attrset", 1))
 107             return 'r';
 108         if (compare_term (li, "prox", 1))
 109             return 'p';
 110         if (compare_term (li, "term", 1))
 111             return 'y';
 112     }
 113     return 't';
 114 }
 115
 116 static int lex (struct lex_info *li)
 117 {
 118     return li->query_look = query_token (li);
 119 }
 120
 121 static int escape_string(char *out_buf, const char *in, int len)
 122 {
 123
 124     char *out = out_buf;
 125     while (--len >= 0)
 126         if (*in == '\\' && len > 0)
 127         {
 128             --len;
 129             switch (*++in)
 130             {
 131             case 't':
 132                 *out++ = '\t';
 133                 break;
 134             case 'n':
 135                 *out++ = '\n';
 136                 break;
 137             case 'r':
 138                 *out++ = '\r';
 139                 break;
 140             case 'f':
 141                 *out++ = '\f';
 142                 break;
 143             case 'x':
 144                 if (len > 1)
 145                 {
 146                     char s[4];
 147                     int n = 0;
 148                     s[0] = *++in;
 149                     s[1] = *++in;
 150                     s[2] = '\0';
 151                     len = len - 2;
 152                     sscanf (s, "%x", &n);
 153                     *out++ = n;
 154                 }
 155                 break;
 156             case '0':
 157             case '1':
 158             case '2':
 159             case '3':
 160                 if (len > 1)
 161                 {
 162                     char s[4];
 163                     int n = 0;
 164                     s[0] = *in;
 165                     s[1] = *++in;
 166                     s[2] = *++in;
 167                     s[3] = '\0';
 168                     len = len - 2;
 169                     sscanf (s, "%o", &n);
 170                     *out++ = n;
 171                 }
 172                 break;
 173             default:
 174                 *out++ = *in;
 175                 break;
 176             }
 177             in++;
 178         }
 179         else
 180             *out++ = *in++;
 181     return out - out_buf;
 182 }
 183
 184 static int p_query_parse_attr(struct lex_info *li, ODR o,
 185                               int num_attr, int *attr_list,
 186                               char **attr_clist, oid_value *attr_set)
 187 {
 188     const char *cp;
 189     if (!(cp = strchr (li->lex_buf, '=')) ||
 190         (size_t) (cp-li->lex_buf) > li->lex_len)
 191     {
 192         attr_set[num_attr] = query_oid_getvalbyname (li);
 193         if (attr_set[num_attr] == VAL_NONE)
 194             return 0;
 195         lex (li);
 196
 197         if (!(cp = strchr (li->lex_buf, '=')))
 198             return 0;
 199     }
 200     else
 201     {
 202         if (num_attr > 0)
 203             attr_set[num_attr] = attr_set[num_attr-1];
 204         else
 205             attr_set[num_attr] = VAL_NONE;
 206     }
 207     attr_list[2*num_attr] = atoi(li->lex_buf);
 208         cp++;
 209     if (*cp >= '0' && *cp <= '9')
 210     {
 211         attr_list[2*num_attr+1] = atoi (cp);
 212         attr_clist[num_attr] = 0;
 213     }
 214     else
 215     {
 216         int len = li->lex_len - (cp - li->lex_buf);
 217         attr_list[2*num_attr+1] = 0;
 218         attr_clist[num_attr] = (char *) odr_malloc (o, len+1);
 219         len = escape_string(attr_clist[num_attr], cp, len);
 220         attr_clist[num_attr][len] = '\0';
 221     }
 222     return 1;
 223 }
 224
 225 static Z_AttributesPlusTerm *rpn_term (struct lex_info *li, ODR o,
 226                                        oid_proto proto,
 227                                        int num_attr, int *attr_list,
 228                                        char **attr_clist, oid_value *attr_set)
 229 {
 230     Z_AttributesPlusTerm *zapt;
 231     Odr_oct *term_octet;
 232     Z_Term *term;
 233     Z_AttributeElement **elements;
 234
 235     zapt = (Z_AttributesPlusTerm *)odr_malloc (o, sizeof(*zapt));
 236     term_octet = (Odr_oct *)odr_malloc (o, sizeof(*term_octet));
 237     term = (Z_Term *)odr_malloc (o, sizeof(*term));
 238
 239     if (!num_attr)
 240         elements = (Z_AttributeElement**)odr_nullval();
 241     else
 242     {
 243         int i, k = 0;
 244         int *attr_tmp;
 245
 246         elements = (Z_AttributeElement**)
 247             odr_malloc (o, num_attr * sizeof(*elements));
 248
 249         attr_tmp = (int *)odr_malloc (o, num_attr * 2 * sizeof(int));
 250         memcpy (attr_tmp, attr_list, num_attr * 2 * sizeof(int));
 251         for (i = num_attr; --i >= 0; )
 252         {
 253             int j;
 254             for (j = i+1; j<num_attr; j++)
 255                 if (attr_tmp[2*j] == attr_tmp[2*i])
 256                     break;
 257             if (j < num_attr)
 258                 continue;
 259             elements[k] =
 260                 (Z_AttributeElement*)odr_malloc (o,sizeof(**elements));
 261             elements[k]->attributeType = &attr_tmp[2*i];
 262             elements[k]->attributeSet =
 263                 yaz_oidval_to_z3950oid(o, CLASS_ATTSET, attr_set[i]);
 264
 265             if (attr_clist[i])
 266             {
 267                 elements[k]->which = Z_AttributeValue_complex;
 268                 elements[k]->value.complex = (Z_ComplexAttribute *)
 269                     odr_malloc (o, sizeof(Z_ComplexAttribute));
 270                 elements[k]->value.complex->num_list = 1;
 271                 elements[k]->value.complex->list =
 272                     (Z_StringOrNumeric **)
 273                     odr_malloc (o, 1 * sizeof(Z_StringOrNumeric *));
 274                 elements[k]->value.complex->list[0] =
 275                     (Z_StringOrNumeric *)
 276                     odr_malloc (o, sizeof(Z_StringOrNumeric));
 277                 elements[k]->value.complex->list[0]->which =
 278                     Z_StringOrNumeric_string;
 279                 elements[k]->value.complex->list[0]->u.string =
 280                     attr_clist[i];
 281                 elements[k]->value.complex->semanticAction = (int **)
 282                     odr_nullval();
 283                 elements[k]->value.complex->num_semanticAction = 0;
 284             }
 285             else
 286             {
 287                 elements[k]->which = Z_AttributeValue_numeric;
 288                 elements[k]->value.numeric = &attr_tmp[2*i+1];
 289             }
 290             k++;
 291         }
 292         num_attr = k;
 293     }
 294     zapt->attributes = (Z_AttributeList *)
 295         odr_malloc (o, sizeof(*zapt->attributes));
 296     zapt->attributes->num_attributes = num_attr;
 297     zapt->attributes->attributes = elements;
 298
 299     zapt->term = term;
 300
 301     term_octet->buf = (unsigned char *)odr_malloc (o, 1 + li->lex_len);
 302     term_octet->size = term_octet->len =
 303         escape_string ((char *) (term_octet->buf), li->lex_buf, li->lex_len);
 304     term_octet->buf[term_octet->size] = 0;  /* null terminate */
 305
 306     switch (li->term_type)
 307     {
 308     case Z_Term_general:
 309         term->which = Z_Term_general;
 310         term->u.general = term_octet;
 311         break;
 312     case Z_Term_characterString:
 313         term->which = Z_Term_characterString;
 314         term->u.characterString = term_octet->buf;  /* null terminated above */
 315         break;
 316     case Z_Term_numeric:
 317         term->which = Z_Term_numeric;
 318         term->u.numeric = odr_intdup (o, atoi(term_octet->buf));
 319         break;
 320     case Z_Term_null:
 321         term->which = Z_Term_null;
 322         term->u.null = odr_nullval();
 323         break;
 324     default:
 325         term->which = Z_Term_null;
 326         term->u.null = odr_nullval();
 327         break;
 328     }
 329     return zapt;
 330 }
 331
 332 static Z_Operand *rpn_simple (struct lex_info *li, ODR o, oid_proto proto,
 333                               int num_attr, int *attr_list, char **attr_clist,
 334                               oid_value *attr_set)
 335 {
 336     Z_Operand *zo;
 337
 338     zo = (Z_Operand *)odr_malloc (o, sizeof(*zo));
 339     switch (li->query_look)
 340     {
 341     case 't':
 342         zo->which = Z_Operand_APT;
 343         if (!(zo->u.attributesPlusTerm =
 344               rpn_term (li, o, proto, num_attr, attr_list, attr_clist,
 345                         attr_set)))
 346             return 0;
 347         lex (li);
 348         break;
 349     case 's':
 350         lex (li);
 351         if (!li->query_look)
 352             return 0;
 353         zo->which = Z_Operand_resultSetId;
 354         zo->u.resultSetId = (char *)odr_malloc (o, li->lex_len+1);
 355         memcpy (zo->u.resultSetId, li->lex_buf, li->lex_len);
 356         zo->u.resultSetId[li->lex_len] = '\0';
 357         lex (li);
 358         break;
 359     default:
 360         return 0;
 361     }
 362     return zo;
 363 }
 364
 365 static Z_ProximityOperator *rpn_proximity (struct lex_info *li, ODR o)
 366 {
 367     Z_ProximityOperator *p = (Z_ProximityOperator *)odr_malloc (o, sizeof(*p));
 368
 369     if (!lex (li))
 370         return NULL;
 371     if (*li->lex_buf == '1')
 372     {
 373         p->exclusion = (int *)odr_malloc (o, sizeof(*p->exclusion));
 374         *p->exclusion = 1;
 375     }
 376     else if (*li->lex_buf == '0')
 377     {
 378         p->exclusion = (int *)odr_malloc (o, sizeof(*p->exclusion));
 379         *p->exclusion = 0;
 380     }
 381     else
 382         p->exclusion = NULL;
 383
 384     if (!lex (li))
 385         return NULL;
 386     p->distance = (int *)odr_malloc (o, sizeof(*p->distance));
 387     *p->distance = atoi (li->lex_buf);
 388
 389     if (!lex (li))
 390         return NULL;
 391     p->ordered = (int *)odr_malloc (o, sizeof(*p->ordered));
 392     *p->ordered = atoi (li->lex_buf);
 393
 394     if (!lex (li))
 395         return NULL;
 396     p->relationType = (int *)odr_malloc (o, sizeof(*p->relationType));
 397     *p->relationType = atoi (li->lex_buf);
 398
 399     if (!lex (li))
 400         return NULL;
 401     if (*li->lex_buf == 'k')
 402         p->which = 0;
 403     else if (*li->lex_buf == 'p')
 404         p->which = 1;
 405     else
 406         p->which = atoi (li->lex_buf);
 407
 408     if (!lex (li))
 409         return NULL;
 410     p->which = Z_ProximityOperator_known;
 411     p->u.known = (int *)odr_malloc (o, sizeof(*p->u.known));
 412     *p->u.known = atoi (li->lex_buf);
 413     return p;
 414 }
 415
 416 static Z_Complex *rpn_complex (struct lex_info *li, ODR o, oid_proto proto,
 417                                int num_attr, int max_attr,
 418                                int *attr_list, char **attr_clist,
 419                                oid_value *attr_set)
 420 {
 421     Z_Complex *zc;
 422     Z_Operator *zo;
 423
 424     zc = (Z_Complex *)odr_malloc (o, sizeof(*zc));
 425     zo = (Z_Operator *)odr_malloc (o, sizeof(*zo));
 426     zc->roperator = zo;
 427     switch (li->query_look)
 428     {
 429     case 'a':
 430         zo->which = Z_Operator_and;
 431         zo->u.and_not = odr_nullval();
 432         break;
 433     case 'o':
 434         zo->which = Z_Operator_or;
 435         zo->u.and_not = odr_nullval();
 436         break;
 437     case 'n':
 438         zo->which = Z_Operator_and_not;
 439         zo->u.and_not = odr_nullval();
 440         break;
 441     case 'p':
 442         zo->which = Z_Operator_prox;
 443         zo->u.prox = rpn_proximity (li, o);
 444         if (!zo->u.prox)
 445             return NULL;
 446         break;
 447     default:
 448         return NULL;
 449     }
 450     lex (li);
 451     if (!(zc->s1 =
 452           rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 453                          attr_clist, attr_set)))
 454         return NULL;
 455     if (!(zc->s2 =
 456           rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 457                          attr_clist, attr_set)))
 458         return NULL;
 459     return zc;
 460 }
 461
 462 static void rpn_term_type (struct lex_info *li, ODR o)
 463 {
 464     if (!li->query_look)
 465         return ;
 466     if (compare_term (li, "general", 0))
 467         li->term_type = Z_Term_general;
 468     else if (compare_term (li, "numeric", 0))
 469         li->term_type = Z_Term_numeric;
 470     else if (compare_term (li, "string", 0))
 471         li->term_type = Z_Term_characterString;
 472     else if (compare_term (li, "oid", 0))
 473         li->term_type = Z_Term_oid;
 474     else if (compare_term (li, "datetime", 0))
 475         li->term_type = Z_Term_dateTime;
 476     else if (compare_term (li, "null", 0))
 477         li->term_type = Z_Term_null;
 478     lex (li);
 479 }
 480
 481 static Z_RPNStructure *rpn_structure (struct lex_info *li, ODR o,
 482                                       oid_proto proto,
 483                                       int num_attr, int max_attr,
 484                                       int *attr_list,
 485                                       char **attr_clist,
 486                                       oid_value *attr_set)
 487 {
 488     Z_RPNStructure *sz;
 489
 490     sz = (Z_RPNStructure *)odr_malloc (o, sizeof(*sz));
 491     switch (li->query_look)
 492     {
 493     case 'a':
 494     case 'o':
 495     case 'n':
 496     case 'p':
 497         sz->which = Z_RPNStructure_complex;
 498         if (!(sz->u.complex =
 499               rpn_complex (li, o, proto, num_attr, max_attr, attr_list,
 500                            attr_clist, attr_set)))
 501             return NULL;
 502         break;
 503     case 't':
 504     case 's':
 505         sz->which = Z_RPNStructure_simple;
 506         if (!(sz->u.simple =
 507               rpn_simple (li, o, proto, num_attr, attr_list,
 508                           attr_clist, attr_set)))
 509             return NULL;
 510         break;
 511     case 'l':
 512         lex (li);
 513         if (!li->query_look)
 514             return NULL;
 515         if (num_attr >= max_attr)
 516             return NULL;
 517         if (!p_query_parse_attr(li, o, num_attr, attr_list,
 518                                 attr_clist, attr_set))
 519             return 0;
 520         num_attr++;
 521         lex (li);
 522         return
 523             rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 524                            attr_clist,  attr_set);
 525     case 'y':
 526         lex (li);
 527         rpn_term_type (li, o);
 528         return
 529             rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 530                            attr_clist, attr_set);
 531     case 0:                /* operator/operand expected! */
 532         return NULL;
 533     }
 534     return sz;
 535 }
 536
 537 Z_RPNQuery *p_query_rpn_mk (ODR o, struct lex_info *li, oid_proto proto,
 538                             const char *qbuf)
 539 {
 540     Z_RPNQuery *zq;
 541     int attr_array[1024];
 542     char *attr_clist[512];
 543     oid_value attr_set[512];
 544     oid_value topSet = VAL_NONE;
 545
 546     zq = (Z_RPNQuery *)odr_malloc (o, sizeof(*zq));
 547     lex (li);
 548     if (li->query_look == 'r')
 549     {
 550         lex (li);
 551         topSet = query_oid_getvalbyname (li);
 552         if (topSet == VAL_NONE)
 553             return NULL;
 554
 555         lex (li);
 556     }
 557     if (topSet == VAL_NONE)
 558         topSet = p_query_dfset;
 559     if (topSet == VAL_NONE)
 560         topSet = VAL_BIB1;
 561
 562     zq->attributeSetId = yaz_oidval_to_z3950oid(o, CLASS_ATTSET, topSet);
 563
 564     if (!zq->attributeSetId)
 565         return 0;
 566
 567     if (!(zq->RPNStructure = rpn_structure (li, o, proto, 0, 512,
 568                                             attr_array, attr_clist, attr_set)))
 569         return NULL;
 570     return zq;
 571 }
 572
 573 Z_RPNQuery *p_query_rpn (ODR o, oid_proto proto,
 574                          const char *qbuf)
 575 {
 576     struct lex_info li;
 577
 578     li.left_sep = "{\"";
 579     li.right_sep = "}\"";
 580     li.escape_char = '@';
 581     li.term_type = Z_Term_general;
 582     li.query_buf = qbuf;
 583     return p_query_rpn_mk (o, &li, proto, qbuf);
 584 }
 585
 586
 587 Z_AttributesPlusTerm *p_query_scan_mk (struct lex_info *li,
 588                                        ODR o, oid_proto proto,
 589                                        Odr_oid **attributeSetP,
 590                                        const char *qbuf)
 591 {
 592     int attr_list[1024];
 593     char *attr_clist[512];
 594     oid_value attr_set[512];
 595     int num_attr = 0;
 596     int max_attr = 512;
 597     oid_value topSet = VAL_NONE;
 598
 599     lex (li);
 600     if (li->query_look == 'r')
 601     {
 602         lex (li);
 603         topSet = query_oid_getvalbyname (li);
 604
 605         lex (li);
 606     }
 607     if (topSet == VAL_NONE)
 608         topSet = p_query_dfset;
 609     if (topSet == VAL_NONE)
 610         topSet = VAL_BIB1;
 611
 612     *attributeSetP = yaz_oidval_to_z3950oid (o, CLASS_ATTSET, topSet);
 613
 614     while (1)
 615     {
 616         if (li->query_look == 'l')
 617         {
 618             lex (li);
 619             if (!li->query_look)
 620                 return 0;
 621             if (num_attr >= max_attr)
 622                 return 0;
 623             if (!p_query_parse_attr(li, o, num_attr, attr_list,
 624                                     attr_clist, attr_set))
 625                 return 0;
 626             num_attr++;
 627             lex (li);
 628         }
 629         else if (li->query_look == 'y')
 630         {
 631             lex (li);
 632             rpn_term_type (li, o);
 633         }
 634         else
 635             break;
 636     }
 637     if (!li->query_look)
 638         return NULL;
 639     return rpn_term (li, o, proto, num_attr, attr_list, attr_clist, attr_set);
 640 }
 641
 642 Z_AttributesPlusTerm *p_query_scan (ODR o, oid_proto proto,
 643                                     Odr_oid **attributeSetP,
 644                                     const char *qbuf)
 645 {
 646     struct lex_info li;
 647
 648     li.left_sep = "{\"";
 649     li.right_sep = "}\"";
 650     li.escape_char = '@';
 651     li.term_type = Z_Term_general;
 652     li.query_buf = qbuf;
 653
 654     return p_query_scan_mk (&li, o, proto, attributeSetP, qbuf);
 655 }
 656
 657 int p_query_attset (const char *arg)
 658 {
 659     p_query_dfset = oid_getvalbyname (arg);
 660     return (p_query_dfset == VAL_NONE) ? -1 : 0;
 661 }
 662