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.15 2002-05-07 11:01:14 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     term->which = Z_Term_general;
 301     term->u.general = term_octet;
 302     term_octet->buf = (unsigned char *)odr_malloc (o, li->lex_len);
 303     term_octet->size = term_octet->len =
 304         escape_string ((char *) (term_octet->buf), li->lex_buf, li->lex_len);
 305     return zapt;
 306 }
 307
 308 static Z_Operand *rpn_simple (struct lex_info *li, ODR o, oid_proto proto,
 309                               int num_attr, int *attr_list, char **attr_clist,
 310                               oid_value *attr_set)
 311 {
 312     Z_Operand *zo;
 313
 314     zo = (Z_Operand *)odr_malloc (o, sizeof(*zo));
 315     switch (li->query_look)
 316     {
 317     case 't':
 318         zo->which = Z_Operand_APT;
 319         if (!(zo->u.attributesPlusTerm =
 320               rpn_term (li, o, proto, num_attr, attr_list, attr_clist,
 321                         attr_set)))
 322             return 0;
 323         lex (li);
 324         break;
 325     case 's':
 326         lex (li);
 327         if (!li->query_look)
 328             return 0;
 329         zo->which = Z_Operand_resultSetId;
 330         zo->u.resultSetId = (char *)odr_malloc (o, li->lex_len+1);
 331         memcpy (zo->u.resultSetId, li->lex_buf, li->lex_len);
 332         zo->u.resultSetId[li->lex_len] = '\0';
 333         lex (li);
 334         break;
 335     default:
 336         return 0;
 337     }
 338     return zo;
 339 }
 340
 341 static Z_ProximityOperator *rpn_proximity (struct lex_info *li, ODR o)
 342 {
 343     Z_ProximityOperator *p = (Z_ProximityOperator *)odr_malloc (o, sizeof(*p));
 344
 345     if (!lex (li))
 346         return NULL;
 347     if (*li->lex_buf == '1')
 348     {
 349         p->exclusion = (int *)odr_malloc (o, sizeof(*p->exclusion));
 350         *p->exclusion = 1;
 351     }
 352     else if (*li->lex_buf == '0')
 353     {
 354         p->exclusion = (int *)odr_malloc (o, sizeof(*p->exclusion));
 355         *p->exclusion = 0;
 356     }
 357     else
 358         p->exclusion = NULL;
 359
 360     if (!lex (li))
 361         return NULL;
 362     p->distance = (int *)odr_malloc (o, sizeof(*p->distance));
 363     *p->distance = atoi (li->lex_buf);
 364
 365     if (!lex (li))
 366         return NULL;
 367     p->ordered = (int *)odr_malloc (o, sizeof(*p->ordered));
 368     *p->ordered = atoi (li->lex_buf);
 369
 370     if (!lex (li))
 371         return NULL;
 372     p->relationType = (int *)odr_malloc (o, sizeof(*p->relationType));
 373     *p->relationType = atoi (li->lex_buf);
 374
 375     if (!lex (li))
 376         return NULL;
 377     if (*li->lex_buf == 'k')
 378         p->which = 0;
 379     else if (*li->lex_buf == 'p')
 380         p->which = 1;
 381     else
 382         p->which = atoi (li->lex_buf);
 383
 384     if (!lex (li))
 385         return NULL;
 386     p->which = Z_ProximityOperator_known;
 387     p->u.known = (int *)odr_malloc (o, sizeof(*p->u.known));
 388     *p->u.known = atoi (li->lex_buf);
 389     return p;
 390 }
 391
 392 static Z_Complex *rpn_complex (struct lex_info *li, ODR o, oid_proto proto,
 393                                int num_attr, int max_attr,
 394                                int *attr_list, char **attr_clist,
 395                                oid_value *attr_set)
 396 {
 397     Z_Complex *zc;
 398     Z_Operator *zo;
 399
 400     zc = (Z_Complex *)odr_malloc (o, sizeof(*zc));
 401     zo = (Z_Operator *)odr_malloc (o, sizeof(*zo));
 402     zc->roperator = zo;
 403     switch (li->query_look)
 404     {
 405     case 'a':
 406         zo->which = Z_Operator_and;
 407         zo->u.and_not = odr_nullval();
 408         break;
 409     case 'o':
 410         zo->which = Z_Operator_or;
 411         zo->u.and_not = odr_nullval();
 412         break;
 413     case 'n':
 414         zo->which = Z_Operator_and_not;
 415         zo->u.and_not = odr_nullval();
 416         break;
 417     case 'p':
 418         zo->which = Z_Operator_prox;
 419         zo->u.prox = rpn_proximity (li, o);
 420         if (!zo->u.prox)
 421             return NULL;
 422         break;
 423     default:
 424         return NULL;
 425     }
 426     lex (li);
 427     if (!(zc->s1 =
 428           rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 429                          attr_clist, attr_set)))
 430         return NULL;
 431     if (!(zc->s2 =
 432           rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 433                          attr_clist, attr_set)))
 434         return NULL;
 435     return zc;
 436 }
 437
 438 static Z_RPNStructure *rpn_structure (struct lex_info *li, ODR o,
 439                                       oid_proto proto,
 440                                       int num_attr, int max_attr,
 441                                       int *attr_list,
 442                                       char **attr_clist,
 443                                       oid_value *attr_set)
 444 {
 445     Z_RPNStructure *sz;
 446
 447     sz = (Z_RPNStructure *)odr_malloc (o, sizeof(*sz));
 448     switch (li->query_look)
 449     {
 450     case 'a':
 451     case 'o':
 452     case 'n':
 453     case 'p':
 454         sz->which = Z_RPNStructure_complex;
 455         if (!(sz->u.complex =
 456               rpn_complex (li, o, proto, num_attr, max_attr, attr_list,
 457                            attr_clist, attr_set)))
 458             return NULL;
 459         break;
 460     case 't':
 461     case 's':
 462         sz->which = Z_RPNStructure_simple;
 463         if (!(sz->u.simple =
 464               rpn_simple (li, o, proto, num_attr, attr_list,
 465                           attr_clist, attr_set)))
 466             return NULL;
 467         break;
 468     case 'l':
 469         lex (li);
 470         if (!li->query_look)
 471             return NULL;
 472         if (num_attr >= max_attr)
 473             return NULL;
 474         if (!p_query_parse_attr(li, o, num_attr, attr_list,
 475                                 attr_clist, attr_set))
 476             return 0;
 477         num_attr++;
 478         lex (li);
 479         return
 480             rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 481                            attr_clist,  attr_set);
 482     case 'y':
 483         lex (li);
 484         if (!li->query_look)
 485             return NULL;
 486         if (compare_term (li, "general", 0))
 487             li->term_type = Z_Term_general;
 488         else if (compare_term (li, "numeric", 0))
 489             li->term_type = Z_Term_numeric;
 490         else if (compare_term (li, "string", 0))
 491             li->term_type = Z_Term_characterString;
 492         else if (compare_term (li, "oid", 0))
 493             li->term_type = Z_Term_oid;
 494         else if (compare_term (li, "datetime", 0))
 495             li->term_type = Z_Term_dateTime;
 496         else if (compare_term (li, "null", 0))
 497             li->term_type = Z_Term_null;
 498         lex (li);
 499         return
 500             rpn_structure (li, o, proto, num_attr, max_attr, attr_list,
 501                            attr_clist, attr_set);
 502     case 0:                /* operator/operand expected! */
 503         return NULL;
 504     }
 505     return sz;
 506 }
 507
 508 Z_RPNQuery *p_query_rpn_mk (ODR o, struct lex_info *li, oid_proto proto,
 509                             const char *qbuf)
 510 {
 511     Z_RPNQuery *zq;
 512     int attr_array[1024];
 513     char *attr_clist[512];
 514     oid_value attr_set[512];
 515     oid_value topSet = VAL_NONE;
 516
 517     zq = (Z_RPNQuery *)odr_malloc (o, sizeof(*zq));
 518     lex (li);
 519     if (li->query_look == 'r')
 520     {
 521         lex (li);
 522         topSet = query_oid_getvalbyname (li);
 523         if (topSet == VAL_NONE)
 524             return NULL;
 525
 526         lex (li);
 527     }
 528     if (topSet == VAL_NONE)
 529         topSet = p_query_dfset;
 530     if (topSet == VAL_NONE)
 531         topSet = VAL_BIB1;
 532
 533     zq->attributeSetId = yaz_oidval_to_z3950oid(o, CLASS_ATTSET, topSet);
 534
 535     if (!zq->attributeSetId)
 536         return 0;
 537
 538     if (!(zq->RPNStructure = rpn_structure (li, o, proto, 0, 512,
 539                                             attr_array, attr_clist, attr_set)))
 540         return NULL;
 541     return zq;
 542 }
 543
 544 Z_RPNQuery *p_query_rpn (ODR o, oid_proto proto,
 545                          const char *qbuf)
 546 {
 547     struct lex_info li;
 548
 549     li.left_sep = "{\"";
 550     li.right_sep = "}\"";
 551     li.escape_char = '@';
 552     li.term_type = Z_Term_general;
 553     li.query_buf = qbuf;
 554     return p_query_rpn_mk (o, &li, proto, qbuf);
 555 }
 556
 557
 558 Z_AttributesPlusTerm *p_query_scan_mk (struct lex_info *li,
 559                                        ODR o, oid_proto proto,
 560                                        Odr_oid **attributeSetP,
 561                                        const char *qbuf)
 562 {
 563     int attr_list[1024];
 564     char *attr_clist[512];
 565     oid_value attr_set[512];
 566     int num_attr = 0;
 567     int max_attr = 512;
 568     oid_value topSet = VAL_NONE;
 569
 570     lex (li);
 571     if (li->query_look == 'r')
 572     {
 573         lex (li);
 574         topSet = query_oid_getvalbyname (li);
 575
 576         lex (li);
 577     }
 578     if (topSet == VAL_NONE)
 579         topSet = p_query_dfset;
 580     if (topSet == VAL_NONE)
 581         topSet = VAL_BIB1;
 582
 583     *attributeSetP = yaz_oidval_to_z3950oid (o, CLASS_ATTSET, topSet);
 584
 585     while (li->query_look == 'l')
 586     {
 587         lex (li);
 588         if (!li->query_look)
 589             return 0;
 590         if (num_attr >= max_attr)
 591             return 0;
 592         if (!p_query_parse_attr(li, o, num_attr, attr_list,
 593                                 attr_clist, attr_set))
 594             return 0;
 595         num_attr++;
 596         lex (li);
 597     }
 598     if (!li->query_look)
 599         return NULL;
 600     return rpn_term (li, o, proto, num_attr, attr_list, attr_clist, attr_set);
 601 }
 602
 603 Z_AttributesPlusTerm *p_query_scan (ODR o, oid_proto proto,
 604                                     Odr_oid **attributeSetP,
 605                                     const char *qbuf)
 606 {
 607     struct lex_info li;
 608
 609     li.left_sep = "{\"";
 610     li.right_sep = "}\"";
 611     li.escape_char = '@';
 612     li.term_type = Z_Term_general;
 613     li.query_buf = qbuf;
 614
 615     return p_query_scan_mk (&li, o, proto, attributeSetP, qbuf);
 616 }
 617
 618 int p_query_attset (const char *arg)
 619 {
 620     p_query_dfset = oid_getvalbyname (arg);
 621     return (p_query_dfset == VAL_NONE) ? -1 : 0;
 622 }
 623