2 * Copyright (C) 1995-2006, Index Data ApS
5 * $Id: xmlquery.c,v 1.10 2006-07-06 10:17:54 adam Exp $
9 \brief Query / XML conversions
17 #include <libxml/parser.h>
18 #include <libxml/tree.h>
20 #include <yaz/logrpn.h>
21 #include <yaz/xmlquery.h>
23 void yaz_query2xml_attribute_element(const Z_AttributeElement *element,
27 const char *setname = 0;
29 if (element->attributeSet)
32 attrset = oid_getentbyoid (element->attributeSet);
33 setname = attrset->desc;
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 oident *attrset = oid_getentbyoid (rpn->attributeSetId);
231 if (attrset && attrset->value)
232 xmlNewProp(parent, BAD_CAST "set", BAD_CAST attrset->desc);
233 return yaz_query2xml_rpnstructure(rpn->RPNStructure, parent);
236 xmlNodePtr yaz_query2xml_ccl(const Odr_oct *ccl, xmlNodePtr node)
241 xmlNodePtr yaz_query2xml_z3958(const Odr_oct *ccl, xmlNodePtr node)
246 xmlNodePtr yaz_query2xml_cql(const char *cql, xmlNodePtr node)
251 void yaz_rpnquery2xml(const Z_RPNQuery *rpn, xmlDocPtr *docp)
255 query.which = Z_Query_type_1;
256 query.u.type_1 = (Z_RPNQuery *) rpn;
257 yaz_query2xml(&query, docp);
260 void yaz_query2xml(const Z_Query *q, xmlDocPtr *docp)
262 xmlNodePtr top_node, q_node = 0, child_node = 0;
267 top_node = xmlNewNode(0, BAD_CAST "query");
272 case Z_Query_type_101:
273 q_node = xmlNewChild(top_node, 0, BAD_CAST "rpn", 0);
274 child_node = yaz_query2xml_rpn(q->u.type_1, q_node);
277 q_node = xmlNewChild(top_node, 0, BAD_CAST "ccl", 0);
278 child_node = yaz_query2xml_ccl(q->u.type_2, q_node);
280 case Z_Query_type_100:
281 q_node = xmlNewChild(top_node, 0, BAD_CAST "z39.58", 0);
282 child_node = yaz_query2xml_z3958(q->u.type_100, q_node);
284 case Z_Query_type_104:
285 if (q->u.type_104->which == Z_External_CQL)
287 q_node = xmlNewChild(top_node, 0, BAD_CAST "cql", 0);
288 child_node = yaz_query2xml_cql(q->u.type_104->u.cql, q_node);
291 if (child_node && q_node)
293 *docp = xmlNewDoc(BAD_CAST "1.0");
294 xmlDocSetRootElement(*docp, top_node); /* make it top node in doc */
299 xmlFreeNode(top_node);
303 bool_t *boolVal(ODR odr, const char *str)
305 if (*str == '\0' || strchr("0fF", *str))
306 return odr_intdup(odr, 0);
307 return odr_intdup(odr, 1);
310 int *intVal(ODR odr, const char *str)
312 return odr_intdup(odr, atoi(str));
315 void yaz_xml2query_operator(const xmlNode *ptr, Z_Operator **op,
316 ODR odr, int *error_code, const char **addinfo)
318 const char *type = (const char *)
319 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "type");
323 *addinfo = "no operator type";
326 *op = (Z_Operator*) odr_malloc(odr, sizeof(Z_Operator));
327 if (!strcmp(type, "and"))
329 (*op)->which = Z_Operator_and;
330 (*op)->u.op_and = odr_nullval();
332 else if (!strcmp(type, "or"))
334 (*op)->which = Z_Operator_or;
335 (*op)->u.op_or = odr_nullval();
337 else if (!strcmp(type, "not"))
339 (*op)->which = Z_Operator_and_not;
340 (*op)->u.and_not = odr_nullval();
342 else if (!strcmp(type, "prox"))
345 Z_ProximityOperator *pop = (Z_ProximityOperator *)
346 odr_malloc(odr, sizeof(Z_ProximityOperator));
348 (*op)->which = Z_Operator_prox;
351 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
352 BAD_CAST "exclusion");
354 pop->exclusion = boolVal(odr, atval);
358 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
359 BAD_CAST "distance");
361 pop->distance = intVal(odr, atval);
363 pop->distance = odr_intdup(odr, 1);
365 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
368 pop->ordered = boolVal(odr, atval);
370 pop->ordered = odr_intdup(odr, 1);
372 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
373 BAD_CAST "relationType");
375 pop->relationType = intVal(odr, atval);
378 odr_intdup(odr, Z_ProximityOperator_Prox_lessThanOrEqual);
380 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
381 BAD_CAST "knownProximityUnit");
384 pop->which = Z_ProximityOperator_known;
385 pop->u.known = intVal(odr, atval);
389 pop->which = Z_ProximityOperator_known;
390 pop->u.known = odr_intdup(odr, Z_ProxUnit_word);
393 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
394 BAD_CAST "privateProximityUnit");
397 pop->which = Z_ProximityOperator_private;
398 pop->u.zprivate = intVal(odr, atval);
404 *addinfo = "bad operator type";
408 void yaz_xml2query_attribute_element(const xmlNode *ptr,
409 Z_AttributeElement **elem, ODR odr,
410 int *error_code, const char **addinfo)
417 struct _xmlAttr *attr;
418 for (attr = ptr->properties; attr; attr = attr->next)
420 if (!xmlStrcmp(attr->name, BAD_CAST "set") &&
421 attr->children && attr->children->type == XML_TEXT_NODE)
422 set = attr->children->content;
423 else if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
424 attr->children && attr->children->type == XML_TEXT_NODE)
425 type = attr->children->content;
426 else if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
427 attr->children && attr->children->type == XML_TEXT_NODE)
429 value = attr->children->content;
435 *addinfo = "bad attribute for attr content";
442 *addinfo = "missing type attribute for att content";
448 *addinfo = "missing value attribute for att content";
452 *elem = (Z_AttributeElement *) odr_malloc(odr, sizeof(**elem));
454 (*elem)->attributeSet = yaz_str_to_z3950oid(odr, CLASS_ATTSET,
457 (*elem)->attributeSet = 0;
458 (*elem)->attributeType = intVal(odr, (const char *) type);
460 /* looks like a number ? */
461 for (i = 0; value[i] && value[i] >= '0' && value[i] <= '9'; i++)
463 if (num_values > 1 || value[i])
464 { /* multiple values or string, so turn to complex attribute */
465 (*elem)->which = Z_AttributeValue_complex;
466 (*elem)->value.complex =
467 (Z_ComplexAttribute*) odr_malloc(odr, sizeof(Z_ComplexAttribute));
468 (*elem)->value.complex->num_list = num_values;
469 (*elem)->value.complex->list = (Z_StringOrNumeric **)
470 odr_malloc(odr, sizeof(Z_StringOrNumeric*) * num_values);
472 /* second pass over attr values */
474 for (attr = ptr->properties; attr; attr = attr->next)
476 if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
477 attr->children && attr->children->type == XML_TEXT_NODE)
479 const char *val = (const char *) attr->children->content;
480 assert (i < num_values);
481 (*elem)->value.complex->list[i] = (Z_StringOrNumeric *)
482 odr_malloc(odr, sizeof(Z_StringOrNumeric));
483 (*elem)->value.complex->list[i]->which =
484 Z_StringOrNumeric_string;
485 (*elem)->value.complex->list[i]->u.string =
486 odr_strdup(odr, val);
490 (*elem)->value.complex->num_semanticAction = 0;
491 (*elem)->value.complex->semanticAction = 0;
494 { /* good'ld numeric value */
495 (*elem)->which = Z_AttributeValue_numeric;
496 (*elem)->value.numeric = intVal(odr, (const char *) value);
500 char *strVal(const xmlNode *ptr_cdata, ODR odr)
502 return nmem_text_node_cdata(ptr_cdata, odr->mem);
505 void yaz_xml2query_term(const xmlNode *ptr,
506 Z_Term **term, ODR odr,
507 int *error_code, const char **addinfo)
510 struct _xmlAttr *attr;
511 char *cdata = strVal(ptr->children, odr);
513 for (attr = ptr->properties; attr; attr = attr->next)
515 if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
516 attr->children && attr->children->type == XML_TEXT_NODE)
517 type = attr->children->content;
521 *addinfo = "bad attribute for attr content";
525 *term = (Z_Term *) odr_malloc(odr, sizeof(Z_Term));
527 if (!type || !xmlStrcmp(type, BAD_CAST "general"))
529 (*term)->which = Z_Term_general;
531 odr_create_Odr_oct(odr, (unsigned char *)cdata, strlen(cdata));
533 else if (!xmlStrcmp(type, BAD_CAST "numeric"))
535 (*term)->which = Z_Term_numeric;
536 (*term)->u.numeric = intVal(odr, cdata);
538 else if (!xmlStrcmp(type, BAD_CAST "string"))
540 (*term)->which = Z_Term_characterString;
541 (*term)->u.characterString = cdata;
543 else if (!xmlStrcmp(type, BAD_CAST "oid"))
546 *addinfo = "unhandled term type: oid";
548 else if (!xmlStrcmp(type, BAD_CAST "dateTime"))
551 *addinfo = "unhandled term type: dateTime";
553 else if (!xmlStrcmp(type, BAD_CAST "integerAndUnit"))
556 *addinfo = "unhandled term type: integerAndUnit";
558 else if (!xmlStrcmp(type, BAD_CAST "null"))
560 (*term)->which = Z_Term_null;
561 (*term)->u.null = odr_nullval();
566 *addinfo = "unhandled term type";
570 void yaz_xml2query_apt(const xmlNode *ptr_apt,
571 Z_AttributesPlusTerm **zapt, ODR odr,
572 int *error_code, const char **addinfo)
574 const xmlNode *ptr = ptr_apt->children;
577 *zapt = (Z_AttributesPlusTerm *)
578 odr_malloc(odr, sizeof(Z_AttributesPlusTerm));
580 /* deal with attributes */
581 (*zapt)->attributes = (Z_AttributeList*)
582 odr_malloc(odr, sizeof(Z_AttributeList));
584 /* how many attributes? */
585 for (; ptr; ptr = ptr->next)
586 if (ptr->type == XML_ELEMENT_NODE)
588 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
594 /* allocate and parse for real */
595 (*zapt)->attributes->num_attributes = num_attr;
596 (*zapt)->attributes->attributes = (Z_AttributeElement **)
597 odr_malloc(odr, sizeof(Z_AttributeElement*) * num_attr);
600 ptr = ptr_apt->children;
601 for (; ptr; ptr = ptr->next)
602 if (ptr->type == XML_ELEMENT_NODE)
604 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
606 yaz_xml2query_attribute_element(
607 ptr, &(*zapt)->attributes->attributes[i], odr,
608 error_code, addinfo);
614 if (ptr && ptr->type == XML_ELEMENT_NODE)
616 if (!xmlStrcmp(ptr->name, BAD_CAST "term"))
619 yaz_xml2query_term(ptr, &(*zapt)->term, odr, error_code, addinfo);
624 *addinfo = "bad element in apt content";
630 *addinfo = "missing term node in apt content";
634 void yaz_xml2query_rset(const xmlNode *ptr, Z_ResultSetId **rset,
635 ODR odr, int *error_code, const char **addinfo)
639 *rset = strVal(ptr->children, odr);
644 *addinfo = "missing rset content";
648 void yaz_xml2query_rpnstructure(const xmlNode *ptr, Z_RPNStructure **zs,
649 ODR odr, int *error_code, const char **addinfo)
651 while (ptr && ptr->type != XML_ELEMENT_NODE)
654 if (!ptr || ptr->type != XML_ELEMENT_NODE)
657 *addinfo = "missing rpn operator, rset, apt node";
660 *zs = (Z_RPNStructure *) odr_malloc(odr, sizeof(Z_RPNStructure));
661 if (!xmlStrcmp(ptr->name, BAD_CAST "operator"))
663 Z_Complex *zc = odr_malloc(odr, sizeof(Z_Complex));
665 (*zs)->which = Z_RPNStructure_complex;
666 (*zs)->u.complex = zc;
668 yaz_xml2query_operator(ptr, &zc->roperator, odr, error_code, addinfo);
671 while (ptr && ptr->type != XML_ELEMENT_NODE)
673 yaz_xml2query_rpnstructure(ptr, &zc->s1, odr, error_code, addinfo);
676 while (ptr && ptr->type != XML_ELEMENT_NODE)
678 yaz_xml2query_rpnstructure(ptr, &zc->s2, odr, error_code, addinfo);
682 Z_Operand *s = (Z_Operand *) odr_malloc(odr, sizeof(Z_Operand));
683 (*zs)->which = Z_RPNStructure_simple;
685 if (!xmlStrcmp(ptr->name, BAD_CAST "apt"))
687 s->which = Z_Operand_APT;
688 yaz_xml2query_apt(ptr, &s->u.attributesPlusTerm,
689 odr, error_code, addinfo);
691 else if (!xmlStrcmp(ptr->name, BAD_CAST "rset"))
693 s->which = Z_Operand_resultSetId;
694 yaz_xml2query_rset(ptr, &s->u.resultSetId,
695 odr, error_code, addinfo);
700 *addinfo = "bad element: expected binary, apt or rset";
705 void yaz_xml2query_rpn(const xmlNode *ptr, Z_RPNQuery **query, ODR odr,
706 int *error_code, const char **addinfo)
708 const char *set = (const char *)
709 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "set");
711 *query = (Z_RPNQuery*) odr_malloc(odr, sizeof(Z_RPNQuery));
713 (*query)->attributeSetId = yaz_str_to_z3950oid(odr, CLASS_ATTSET, set);
715 (*query)->attributeSetId = 0;
716 yaz_xml2query_rpnstructure(ptr->children, &(*query)->RPNStructure,
717 odr, error_code, addinfo);
720 static void yaz_xml2query_(const xmlNode *ptr, Z_Query **query, ODR odr,
721 int *error_code, const char **addinfo)
723 if (ptr && ptr->type == XML_ELEMENT_NODE &&
724 !xmlStrcmp(ptr->name, BAD_CAST "query"))
728 while (ptr && ptr->type != XML_ELEMENT_NODE)
730 if (!ptr || ptr->type != XML_ELEMENT_NODE)
733 *addinfo = "missing query content";
736 type = (const char *) ptr->name;
738 *query = (Z_Query*) odr_malloc(odr, sizeof(Z_Query));
739 if (!type || !strcmp(type, "rpn"))
741 (*query)->which = Z_Query_type_1;
742 yaz_xml2query_rpn(ptr, &(*query)->u.type_1, odr,
743 error_code, addinfo);
745 else if (!strcmp(type, "ccl"))
748 *addinfo = "ccl not supported yet";
750 else if (!strcmp(type, "z39.58"))
753 *addinfo = "z39.58 not supported yet";
755 else if (!strcmp(type, "cql"))
758 *addinfo = "cql not supported yet";
763 *addinfo = "unsupported query type";
769 *addinfo = "missing query element";
773 void yaz_xml2query(const void *xmlnodep, Z_Query **query, ODR odr,
774 int *error_code, const char **addinfo)
776 yaz_xml2query_(xmlnodep, query, odr, error_code, addinfo);
785 * indent-tabs-mode: nil
787 * vim: shiftwidth=4 tabstop=8 expandtab