1 /* This file is part of the YAZ toolkit.
2 * Copyright (C) 1995-2008 Index Data
3 * See the file LICENSE for details.
7 \brief Query / XML conversions
15 #include <libxml/parser.h>
16 #include <libxml/tree.h>
18 #include <yaz/logrpn.h>
19 #include <yaz/xmlquery.h>
20 #include <yaz/nmem_xml.h>
21 #include <yaz/oid_db.h>
23 void yaz_query2xml_attribute_element(const Z_AttributeElement *element,
27 const char *setname = 0;
28 char oid_name_str[OID_STR_MAX];
30 if (element->attributeSet)
32 setname = yaz_oid_to_string_buf(element->attributeSet,
36 if (element->which == Z_AttributeValue_numeric)
38 xmlNodePtr node = xmlNewChild(parent, 0, BAD_CAST "attr", 0);
41 xmlNewProp(node, BAD_CAST "set", BAD_CAST setname);
43 sprintf(formstr, "%d", *element->attributeType);
44 xmlNewProp(node, BAD_CAST "type", BAD_CAST formstr);
46 sprintf(formstr, "%d", *element->value.numeric);
47 xmlNewProp(node, BAD_CAST "value", BAD_CAST formstr);
49 else if (element->which == Z_AttributeValue_complex)
52 for (i = 0; i<element->value.complex->num_list; i++)
54 xmlNodePtr node = xmlNewChild(parent, 0, BAD_CAST "attr", 0);
57 xmlNewProp(node, BAD_CAST "set", BAD_CAST setname);
59 sprintf(formstr, "%d", *element->attributeType);
60 xmlNewProp(node, BAD_CAST "type", BAD_CAST formstr);
62 if (element->value.complex->list[i]->which ==
63 Z_StringOrNumeric_string)
65 xmlNewProp(node, BAD_CAST "value", BAD_CAST
66 element->value.complex->list[i]->u.string);
68 else if (element->value.complex->list[i]->which ==
69 Z_StringOrNumeric_numeric)
71 sprintf(formstr, "%d",
72 *element->value.complex->list[i]->u.numeric);
73 xmlNewProp(node, BAD_CAST "value", BAD_CAST formstr);
80 xmlNodePtr yaz_query2xml_term(const Z_Term *term,
84 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "term", 0);
92 t = xmlNewTextLen(BAD_CAST term->u.general->buf, term->u.general->len);
96 sprintf(formstr, "%d", *term->u.numeric);
97 t = xmlNewText(BAD_CAST formstr);
99 case Z_Term_characterString:
101 t = xmlNewText(BAD_CAST term->u.characterString);
106 case Z_Term_dateTime:
109 case Z_Term_external:
112 case Z_Term_integerAndUnit:
113 type ="integerAndUnit";
121 if (t) /* got a term node ? */
122 xmlAddChild(node, t);
124 xmlNewProp(node, BAD_CAST "type", BAD_CAST type);
128 xmlNodePtr yaz_query2xml_apt(const Z_AttributesPlusTerm *zapt,
131 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "apt", 0);
132 int num_attributes = zapt->attributes->num_attributes;
134 for (i = 0; i<num_attributes; i++)
135 yaz_query2xml_attribute_element(zapt->attributes->attributes[i], node);
136 yaz_query2xml_term(zapt->term, node);
142 void yaz_query2xml_operator(Z_Operator *op, xmlNodePtr node)
144 const char *type = 0;
153 case Z_Operator_and_not:
156 case Z_Operator_prox:
162 xmlNewProp(node, BAD_CAST "type", BAD_CAST type);
164 if (op->which == Z_Operator_prox)
168 if (op->u.prox->exclusion)
170 if (*op->u.prox->exclusion)
171 xmlNewProp(node, BAD_CAST "exclusion", BAD_CAST "true");
173 xmlNewProp(node, BAD_CAST "exclusion", BAD_CAST "false");
175 sprintf(formstr, "%d", *op->u.prox->distance);
176 xmlNewProp(node, BAD_CAST "distance", BAD_CAST formstr);
178 if (*op->u.prox->ordered)
179 xmlNewProp(node, BAD_CAST "ordered", BAD_CAST "true");
181 xmlNewProp(node, BAD_CAST "ordered", BAD_CAST "false");
183 sprintf(formstr, "%d", *op->u.prox->relationType);
184 xmlNewProp(node, BAD_CAST "relationType", BAD_CAST formstr);
186 switch(op->u.prox->which)
188 case Z_ProximityOperator_known:
189 sprintf(formstr, "%d", *op->u.prox->u.known);
190 xmlNewProp(node, BAD_CAST "knownProximityUnit",
193 case Z_ProximityOperator_private:
195 xmlNewProp(node, BAD_CAST "privateProximityUnit",
202 xmlNodePtr yaz_query2xml_rpnstructure(const Z_RPNStructure *zs,
205 if (zs->which == Z_RPNStructure_complex)
207 Z_Complex *zc = zs->u.complex;
209 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "operator", 0);
211 yaz_query2xml_operator(zc->roperator, node);
212 yaz_query2xml_rpnstructure(zc->s1, node);
213 yaz_query2xml_rpnstructure(zc->s2, node);
216 else if (zs->which == Z_RPNStructure_simple)
218 if (zs->u.simple->which == Z_Operand_APT)
219 return yaz_query2xml_apt(zs->u.simple->u.attributesPlusTerm,
221 else if (zs->u.simple->which == Z_Operand_resultSetId)
222 return xmlNewChild(parent, /* NS */ 0, BAD_CAST "rset",
223 BAD_CAST zs->u.simple->u.resultSetId);
228 xmlNodePtr yaz_query2xml_rpn(const Z_RPNQuery *rpn, xmlNodePtr parent)
230 if (rpn->attributeSetId)
232 char oid_name_str[OID_STR_MAX];
233 const char *setname = yaz_oid_to_string_buf(rpn->attributeSetId,
236 xmlNewProp(parent, BAD_CAST "set", BAD_CAST setname);
238 return yaz_query2xml_rpnstructure(rpn->RPNStructure, parent);
241 xmlNodePtr yaz_query2xml_ccl(const Odr_oct *ccl, xmlNodePtr node)
246 xmlNodePtr yaz_query2xml_z3958(const Odr_oct *ccl, xmlNodePtr node)
251 xmlNodePtr yaz_query2xml_cql(const char *cql, xmlNodePtr node)
256 void yaz_rpnquery2xml(const Z_RPNQuery *rpn, xmlDocPtr *docp)
260 query.which = Z_Query_type_1;
261 query.u.type_1 = (Z_RPNQuery *) rpn;
262 yaz_query2xml(&query, docp);
265 void yaz_query2xml(const Z_Query *q, xmlDocPtr *docp)
267 xmlNodePtr top_node, q_node = 0, child_node = 0;
272 top_node = xmlNewNode(0, BAD_CAST "query");
277 case Z_Query_type_101:
278 q_node = xmlNewChild(top_node, 0, BAD_CAST "rpn", 0);
279 child_node = yaz_query2xml_rpn(q->u.type_1, q_node);
282 q_node = xmlNewChild(top_node, 0, BAD_CAST "ccl", 0);
283 child_node = yaz_query2xml_ccl(q->u.type_2, q_node);
285 case Z_Query_type_100:
286 q_node = xmlNewChild(top_node, 0, BAD_CAST "z39.58", 0);
287 child_node = yaz_query2xml_z3958(q->u.type_100, q_node);
289 case Z_Query_type_104:
290 if (q->u.type_104->which == Z_External_CQL)
292 q_node = xmlNewChild(top_node, 0, BAD_CAST "cql", 0);
293 child_node = yaz_query2xml_cql(q->u.type_104->u.cql, q_node);
296 if (child_node && q_node)
298 *docp = xmlNewDoc(BAD_CAST "1.0");
299 xmlDocSetRootElement(*docp, top_node); /* make it top node in doc */
304 xmlFreeNode(top_node);
308 bool_t *boolVal(ODR odr, const char *str)
310 if (*str == '\0' || strchr("0fF", *str))
311 return odr_intdup(odr, 0);
312 return odr_intdup(odr, 1);
315 int *intVal(ODR odr, const char *str)
317 return odr_intdup(odr, atoi(str));
320 void yaz_xml2query_operator(const xmlNode *ptr, Z_Operator **op,
321 ODR odr, int *error_code, const char **addinfo)
323 const char *type = (const char *)
324 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "type");
328 *addinfo = "no operator type";
331 *op = (Z_Operator*) odr_malloc(odr, sizeof(Z_Operator));
332 if (!strcmp(type, "and"))
334 (*op)->which = Z_Operator_and;
335 (*op)->u.op_and = odr_nullval();
337 else if (!strcmp(type, "or"))
339 (*op)->which = Z_Operator_or;
340 (*op)->u.op_or = odr_nullval();
342 else if (!strcmp(type, "not"))
344 (*op)->which = Z_Operator_and_not;
345 (*op)->u.and_not = odr_nullval();
347 else if (!strcmp(type, "prox"))
350 Z_ProximityOperator *pop = (Z_ProximityOperator *)
351 odr_malloc(odr, sizeof(Z_ProximityOperator));
353 (*op)->which = Z_Operator_prox;
356 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
357 BAD_CAST "exclusion");
359 pop->exclusion = boolVal(odr, atval);
363 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
364 BAD_CAST "distance");
366 pop->distance = intVal(odr, atval);
368 pop->distance = odr_intdup(odr, 1);
370 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
373 pop->ordered = boolVal(odr, atval);
375 pop->ordered = odr_intdup(odr, 1);
377 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
378 BAD_CAST "relationType");
380 pop->relationType = intVal(odr, atval);
383 odr_intdup(odr, Z_ProximityOperator_Prox_lessThanOrEqual);
385 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
386 BAD_CAST "knownProximityUnit");
389 pop->which = Z_ProximityOperator_known;
390 pop->u.known = intVal(odr, atval);
394 pop->which = Z_ProximityOperator_known;
395 pop->u.known = odr_intdup(odr, Z_ProxUnit_word);
398 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
399 BAD_CAST "privateProximityUnit");
402 pop->which = Z_ProximityOperator_private;
403 pop->u.zprivate = intVal(odr, atval);
409 *addinfo = "bad operator type";
413 void yaz_xml2query_attribute_element(const xmlNode *ptr,
414 Z_AttributeElement **elem, ODR odr,
415 int *error_code, const char **addinfo)
422 struct _xmlAttr *attr;
423 for (attr = ptr->properties; attr; attr = attr->next)
425 if (!xmlStrcmp(attr->name, BAD_CAST "set") &&
426 attr->children && attr->children->type == XML_TEXT_NODE)
427 set = attr->children->content;
428 else if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
429 attr->children && attr->children->type == XML_TEXT_NODE)
430 type = attr->children->content;
431 else if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
432 attr->children && attr->children->type == XML_TEXT_NODE)
434 value = attr->children->content;
440 *addinfo = "bad attribute for attr content";
447 *addinfo = "missing type attribute for att content";
453 *addinfo = "missing value attribute for att content";
457 *elem = (Z_AttributeElement *) odr_malloc(odr, sizeof(**elem));
459 (*elem)->attributeSet = yaz_string_to_oid_odr(yaz_oid_std(),
464 (*elem)->attributeSet = 0;
465 (*elem)->attributeType = intVal(odr, (const char *) type);
467 /* looks like a number ? */
468 for (i = 0; value[i] && value[i] >= '0' && value[i] <= '9'; i++)
470 if (num_values > 1 || value[i])
471 { /* multiple values or string, so turn to complex attribute */
472 (*elem)->which = Z_AttributeValue_complex;
473 (*elem)->value.complex =
474 (Z_ComplexAttribute*) odr_malloc(odr, sizeof(Z_ComplexAttribute));
475 (*elem)->value.complex->num_list = num_values;
476 (*elem)->value.complex->list = (Z_StringOrNumeric **)
477 odr_malloc(odr, sizeof(Z_StringOrNumeric*) * num_values);
479 /* second pass over attr values */
481 for (attr = ptr->properties; attr; attr = attr->next)
483 if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
484 attr->children && attr->children->type == XML_TEXT_NODE)
486 const char *val = (const char *) attr->children->content;
487 assert (i < num_values);
488 (*elem)->value.complex->list[i] = (Z_StringOrNumeric *)
489 odr_malloc(odr, sizeof(Z_StringOrNumeric));
490 (*elem)->value.complex->list[i]->which =
491 Z_StringOrNumeric_string;
492 (*elem)->value.complex->list[i]->u.string =
493 odr_strdup(odr, val);
497 (*elem)->value.complex->num_semanticAction = 0;
498 (*elem)->value.complex->semanticAction = 0;
501 { /* good'ld numeric value */
502 (*elem)->which = Z_AttributeValue_numeric;
503 (*elem)->value.numeric = intVal(odr, (const char *) value);
507 char *strVal(const xmlNode *ptr_cdata, ODR odr)
509 return nmem_text_node_cdata(ptr_cdata, odr_getmem(odr));
512 void yaz_xml2query_term(const xmlNode *ptr,
513 Z_Term **term, ODR odr,
514 int *error_code, const char **addinfo)
517 struct _xmlAttr *attr;
518 char *cdata = strVal(ptr->children, odr);
520 for (attr = ptr->properties; attr; attr = attr->next)
522 if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
523 attr->children && attr->children->type == XML_TEXT_NODE)
524 type = attr->children->content;
528 *addinfo = "bad attribute for attr content";
532 *term = (Z_Term *) odr_malloc(odr, sizeof(Z_Term));
534 if (!type || !xmlStrcmp(type, BAD_CAST "general"))
536 (*term)->which = Z_Term_general;
538 odr_create_Odr_oct(odr, (unsigned char *)cdata, strlen(cdata));
540 else if (!xmlStrcmp(type, BAD_CAST "numeric"))
542 (*term)->which = Z_Term_numeric;
543 (*term)->u.numeric = intVal(odr, cdata);
545 else if (!xmlStrcmp(type, BAD_CAST "string"))
547 (*term)->which = Z_Term_characterString;
548 (*term)->u.characterString = cdata;
550 else if (!xmlStrcmp(type, BAD_CAST "oid"))
553 *addinfo = "unhandled term type: oid";
555 else if (!xmlStrcmp(type, BAD_CAST "dateTime"))
558 *addinfo = "unhandled term type: dateTime";
560 else if (!xmlStrcmp(type, BAD_CAST "integerAndUnit"))
563 *addinfo = "unhandled term type: integerAndUnit";
565 else if (!xmlStrcmp(type, BAD_CAST "null"))
567 (*term)->which = Z_Term_null;
568 (*term)->u.null = odr_nullval();
573 *addinfo = "unhandled term type";
577 void yaz_xml2query_apt(const xmlNode *ptr_apt,
578 Z_AttributesPlusTerm **zapt, ODR odr,
579 int *error_code, const char **addinfo)
581 const xmlNode *ptr = ptr_apt->children;
584 *zapt = (Z_AttributesPlusTerm *)
585 odr_malloc(odr, sizeof(Z_AttributesPlusTerm));
587 /* deal with attributes */
588 (*zapt)->attributes = (Z_AttributeList*)
589 odr_malloc(odr, sizeof(Z_AttributeList));
591 /* how many attributes? */
592 for (; ptr; ptr = ptr->next)
593 if (ptr->type == XML_ELEMENT_NODE)
595 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
601 /* allocate and parse for real */
602 (*zapt)->attributes->num_attributes = num_attr;
603 (*zapt)->attributes->attributes = (Z_AttributeElement **)
604 odr_malloc(odr, sizeof(Z_AttributeElement*) * num_attr);
607 ptr = ptr_apt->children;
608 for (; ptr; ptr = ptr->next)
609 if (ptr->type == XML_ELEMENT_NODE)
611 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
613 yaz_xml2query_attribute_element(
614 ptr, &(*zapt)->attributes->attributes[i], odr,
615 error_code, addinfo);
621 if (ptr && ptr->type == XML_ELEMENT_NODE)
623 if (!xmlStrcmp(ptr->name, BAD_CAST "term"))
626 yaz_xml2query_term(ptr, &(*zapt)->term, odr, error_code, addinfo);
631 *addinfo = "bad element in apt content";
637 *addinfo = "missing term node in apt content";
641 void yaz_xml2query_rset(const xmlNode *ptr, Z_ResultSetId **rset,
642 ODR odr, int *error_code, const char **addinfo)
646 *rset = strVal(ptr->children, odr);
651 *addinfo = "missing rset content";
655 void yaz_xml2query_rpnstructure(const xmlNode *ptr, Z_RPNStructure **zs,
656 ODR odr, int *error_code, const char **addinfo)
658 while (ptr && ptr->type != XML_ELEMENT_NODE)
661 if (!ptr || ptr->type != XML_ELEMENT_NODE)
664 *addinfo = "missing rpn operator, rset, apt node";
667 *zs = (Z_RPNStructure *) odr_malloc(odr, sizeof(Z_RPNStructure));
668 if (!xmlStrcmp(ptr->name, BAD_CAST "operator"))
670 Z_Complex *zc = (Z_Complex *) odr_malloc(odr, sizeof(Z_Complex));
672 (*zs)->which = Z_RPNStructure_complex;
673 (*zs)->u.complex = zc;
675 yaz_xml2query_operator(ptr, &zc->roperator, odr, error_code, addinfo);
678 while (ptr && ptr->type != XML_ELEMENT_NODE)
680 yaz_xml2query_rpnstructure(ptr, &zc->s1, odr, error_code, addinfo);
683 while (ptr && ptr->type != XML_ELEMENT_NODE)
685 yaz_xml2query_rpnstructure(ptr, &zc->s2, odr, error_code, addinfo);
689 Z_Operand *s = (Z_Operand *) odr_malloc(odr, sizeof(Z_Operand));
690 (*zs)->which = Z_RPNStructure_simple;
692 if (!xmlStrcmp(ptr->name, BAD_CAST "apt"))
694 s->which = Z_Operand_APT;
695 yaz_xml2query_apt(ptr, &s->u.attributesPlusTerm,
696 odr, error_code, addinfo);
698 else if (!xmlStrcmp(ptr->name, BAD_CAST "rset"))
700 s->which = Z_Operand_resultSetId;
701 yaz_xml2query_rset(ptr, &s->u.resultSetId,
702 odr, error_code, addinfo);
707 *addinfo = "bad element: expected binary, apt or rset";
712 void yaz_xml2query_rpn(const xmlNode *ptr, Z_RPNQuery **query, ODR odr,
713 int *error_code, const char **addinfo)
715 const char *set = (const char *)
716 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "set");
718 *query = (Z_RPNQuery*) odr_malloc(odr, sizeof(Z_RPNQuery));
720 (*query)->attributeSetId = yaz_string_to_oid_odr(yaz_oid_std(),
721 CLASS_ATTSET, set, odr);
723 (*query)->attributeSetId = 0;
724 yaz_xml2query_rpnstructure(ptr->children, &(*query)->RPNStructure,
725 odr, error_code, addinfo);
728 static void yaz_xml2query_(const xmlNode *ptr, Z_Query **query, ODR odr,
729 int *error_code, const char **addinfo)
731 if (ptr && ptr->type == XML_ELEMENT_NODE &&
732 !xmlStrcmp(ptr->name, BAD_CAST "query"))
736 while (ptr && ptr->type != XML_ELEMENT_NODE)
738 if (!ptr || ptr->type != XML_ELEMENT_NODE)
741 *addinfo = "missing query content";
744 type = (const char *) ptr->name;
746 *query = (Z_Query*) odr_malloc(odr, sizeof(Z_Query));
747 if (!type || !strcmp(type, "rpn"))
749 (*query)->which = Z_Query_type_1;
750 yaz_xml2query_rpn(ptr, &(*query)->u.type_1, odr,
751 error_code, addinfo);
753 else if (!strcmp(type, "ccl"))
756 *addinfo = "ccl not supported yet";
758 else if (!strcmp(type, "z39.58"))
761 *addinfo = "z39.58 not supported yet";
763 else if (!strcmp(type, "cql"))
766 *addinfo = "cql not supported yet";
771 *addinfo = "unsupported query type";
777 *addinfo = "missing query element";
781 void yaz_xml2query(const xmlNode *xmlnodep, Z_Query **query, ODR odr,
782 int *error_code, const char **addinfo)
784 yaz_xml2query_(xmlnodep, query, odr, error_code, addinfo);
793 * indent-tabs-mode: nil
795 * vim: shiftwidth=4 tabstop=8 expandtab