2 * Copyright (C) 1995-2005, Index Data ApS
5 * $Id: xmlquery.c,v 1.4 2006-02-19 18:44:23 adam Exp $
10 * \brief Query / XML conversions
18 #include <libxml/parser.h>
19 #include <libxml/tree.h>
21 #include <yaz/logrpn.h>
22 #include <yaz/xmlquery.h>
24 void yaz_query2xml_attribute_element(const Z_AttributeElement *element,
28 const char *setname = 0;
30 if (element->attributeSet)
33 attrset = oid_getentbyoid (element->attributeSet);
34 setname = attrset->desc;
37 if (element->which == Z_AttributeValue_numeric)
39 xmlNodePtr node = xmlNewChild(parent, 0, BAD_CAST "attr", 0);
42 xmlNewProp(node, BAD_CAST "set", BAD_CAST setname);
44 sprintf(formstr, "%d", *element->attributeType);
45 xmlNewProp(node, BAD_CAST "type", BAD_CAST formstr);
47 sprintf(formstr, "%d", *element->value.numeric);
48 xmlNewProp(node, BAD_CAST "value", BAD_CAST formstr);
50 else if (element->which == Z_AttributeValue_complex)
53 for (i = 0; i<element->value.complex->num_list; i++)
55 xmlNodePtr node = xmlNewChild(parent, 0, BAD_CAST "attr", 0);
58 xmlNewProp(node, BAD_CAST "set", BAD_CAST setname);
60 sprintf(formstr, "%d", *element->attributeType);
61 xmlNewProp(node, BAD_CAST "type", BAD_CAST formstr);
63 if (element->value.complex->list[i]->which ==
64 Z_StringOrNumeric_string)
66 xmlNewProp(node, BAD_CAST "value", BAD_CAST
67 element->value.complex->list[i]->u.string);
69 else if (element->value.complex->list[i]->which ==
70 Z_StringOrNumeric_numeric)
72 sprintf(formstr, "%d",
73 *element->value.complex->list[i]->u.numeric);
74 xmlNewProp(node, BAD_CAST "value", BAD_CAST formstr);
81 xmlNodePtr yaz_query2xml_term(const Z_Term *term,
85 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "term", 0);
93 t = xmlNewTextLen(BAD_CAST term->u.general->buf, term->u.general->len);
97 sprintf(formstr, "%d", *term->u.numeric);
98 t = xmlNewText(BAD_CAST formstr);
100 case Z_Term_characterString:
102 t = xmlNewText(BAD_CAST term->u.characterString);
107 case Z_Term_dateTime:
110 case Z_Term_external:
113 case Z_Term_integerAndUnit:
114 type ="integerAndUnit";
122 if (t) /* got a term node ? */
123 xmlAddChild(node, t);
125 xmlNewProp(node, BAD_CAST "type", BAD_CAST type);
129 xmlNodePtr yaz_query2xml_apt(const Z_AttributesPlusTerm *zapt,
132 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "apt", 0);
133 int num_attributes = zapt->attributes->num_attributes;
135 for (i = 0; i<num_attributes; i++)
136 yaz_query2xml_attribute_element(zapt->attributes->attributes[i], node);
137 yaz_query2xml_term(zapt->term, node);
143 void yaz_query2xml_operator(Z_Operator *op, xmlNodePtr node)
145 const char *type = 0;
154 case Z_Operator_and_not:
157 case Z_Operator_prox:
163 xmlNewProp(node, BAD_CAST "type", BAD_CAST type);
165 if (op->which == Z_Operator_prox)
169 if (op->u.prox->exclusion)
171 if (*op->u.prox->exclusion)
172 xmlNewProp(node, BAD_CAST "exclusion", BAD_CAST "true");
174 xmlNewProp(node, BAD_CAST "exclusion", BAD_CAST "false");
176 sprintf(formstr, "%d", *op->u.prox->distance);
177 xmlNewProp(node, BAD_CAST "distance", BAD_CAST formstr);
179 if (*op->u.prox->ordered)
180 xmlNewProp(node, BAD_CAST "ordered", BAD_CAST "true");
182 xmlNewProp(node, BAD_CAST "ordered", BAD_CAST "false");
184 sprintf(formstr, "%d", *op->u.prox->relationType);
185 xmlNewProp(node, BAD_CAST "relationType", BAD_CAST formstr);
187 switch(op->u.prox->which)
189 case Z_ProximityOperator_known:
190 sprintf(formstr, "%d", *op->u.prox->u.known);
191 xmlNewProp(node, BAD_CAST "knownProximityUnit",
194 case Z_ProximityOperator_private:
196 xmlNewProp(node, BAD_CAST "privateProximityUnit",
203 xmlNodePtr yaz_query2xml_rpnstructure(const Z_RPNStructure *zs,
206 if (zs->which == Z_RPNStructure_complex)
208 Z_Complex *zc = zs->u.complex;
210 xmlNodePtr node = xmlNewChild(parent, /* NS */ 0, BAD_CAST "binary", 0);
212 yaz_query2xml_operator(zc->roperator, node);
213 yaz_query2xml_rpnstructure(zc->s1, node);
214 yaz_query2xml_rpnstructure(zc->s2, node);
217 else if (zs->which == Z_RPNStructure_simple)
219 if (zs->u.simple->which == Z_Operand_APT)
220 return yaz_query2xml_apt(zs->u.simple->u.attributesPlusTerm,
222 else if (zs->u.simple->which == Z_Operand_resultSetId)
223 return xmlNewChild(parent, /* NS */ 0, BAD_CAST "rset",
224 BAD_CAST zs->u.simple->u.resultSetId);
229 xmlNodePtr yaz_query2xml_rpn(const Z_RPNQuery *rpn, xmlNodePtr parent)
231 oident *attrset = oid_getentbyoid (rpn->attributeSetId);
232 if (attrset && attrset->value)
233 xmlNewProp(parent, BAD_CAST "set", BAD_CAST attrset->desc);
234 return yaz_query2xml_rpnstructure(rpn->RPNStructure, parent);
237 xmlNodePtr yaz_query2xml_ccl(const Odr_oct *ccl, xmlNodePtr node)
242 xmlNodePtr yaz_query2xml_z3958(const Odr_oct *ccl, xmlNodePtr node)
247 xmlNodePtr yaz_query2xml_cql(const char *cql, xmlNodePtr node)
252 void yaz_rpnquery2xml(const Z_RPNQuery *rpn, void *docp_void)
256 query.which = Z_Query_type_1;
257 query.u.type_1 = (Z_RPNQuery *) rpn;
258 yaz_query2xml(&query, docp_void);
261 void yaz_query2xml(const Z_Query *q, void *docp_void)
263 xmlDocPtr *docp = (xmlDocPtr *) docp_void;
264 xmlNodePtr top_node, child_node = 0;
265 const char *type = 0;
270 top_node = xmlNewNode(0, BAD_CAST "query");
275 case Z_Query_type_101:
277 child_node = yaz_query2xml_rpn(q->u.type_1, top_node);
281 child_node = yaz_query2xml_ccl(q->u.type_2, top_node);
283 case Z_Query_type_100:
285 child_node = yaz_query2xml_z3958(q->u.type_100, top_node);
287 case Z_Query_type_104:
288 if (q->u.type_104->which == Z_External_CQL)
291 child_node = yaz_query2xml_cql(q->u.type_104->u.cql, top_node);
294 if (child_node && type)
296 *docp = xmlNewDoc(BAD_CAST "1.0");
297 xmlDocSetRootElement(*docp, top_node); /* make it top node in doc */
299 /* set type attribute now */
300 xmlNewProp(top_node, BAD_CAST "type", BAD_CAST type);
305 xmlFreeNode(top_node);
309 bool_t *boolVal(ODR odr, const char *str)
311 if (*str == '\0' || strchr("0fF", *str))
312 return odr_intdup(odr, 0);
313 return odr_intdup(odr, 1);
316 int *intVal(ODR odr, const char *str)
318 return odr_intdup(odr, atoi(str));
321 void yaz_xml2query_operator(const xmlNode *ptr, Z_Operator **op,
322 ODR odr, int *error_code, const char **addinfo)
324 const char *type = (const char *)
325 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "type");
329 *addinfo = "no operator type";
332 *op = (Z_Operator*) odr_malloc(odr, sizeof(Z_Operator));
333 if (!strcmp(type, "and"))
335 (*op)->which = Z_Operator_and;
336 (*op)->u.op_and = odr_nullval();
338 else if (!strcmp(type, "or"))
340 (*op)->which = Z_Operator_or;
341 (*op)->u.op_or = odr_nullval();
343 else if (!strcmp(type, "not"))
345 (*op)->which = Z_Operator_and_not;
346 (*op)->u.and_not = odr_nullval();
348 else if (!strcmp(type, "prox"))
351 Z_ProximityOperator *pop = (Z_ProximityOperator *)
352 odr_malloc(odr, sizeof(Z_ProximityOperator));
354 (*op)->which = Z_Operator_prox;
357 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
358 BAD_CAST "exclusion");
360 pop->exclusion = boolVal(odr, atval);
364 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
365 BAD_CAST "distance");
367 pop->distance = intVal(odr, atval);
369 pop->distance = odr_intdup(odr, 1);
371 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
374 pop->ordered = boolVal(odr, atval);
376 pop->ordered = odr_intdup(odr, 1);
378 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
379 BAD_CAST "relationType");
381 pop->relationType = intVal(odr, atval);
384 odr_intdup(odr, Z_ProximityOperator_Prox_lessThanOrEqual);
386 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
387 BAD_CAST "knownProximityUnit");
390 pop->which = Z_ProximityOperator_known;
391 pop->u.known = intVal(odr, atval);
395 pop->which = Z_ProximityOperator_known;
396 pop->u.known = odr_intdup(odr, Z_ProxUnit_word);
399 atval = (const char *) xmlGetProp((xmlNodePtr) ptr,
400 BAD_CAST "privateProximityUnit");
403 pop->which = Z_ProximityOperator_private;
404 pop->u.zprivate = intVal(odr, atval);
410 *addinfo = "bad operator type";
414 void yaz_xml2query_attribute_element(const xmlNode *ptr,
415 Z_AttributeElement **elem, ODR odr,
416 int *error_code, const char **addinfo)
423 struct _xmlAttr *attr;
424 for (attr = ptr->properties; attr; attr = attr->next)
426 if (!xmlStrcmp(attr->name, BAD_CAST "set") &&
427 attr->children && attr->children->type == XML_TEXT_NODE)
428 set = attr->children->content;
429 else if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
430 attr->children && attr->children->type == XML_TEXT_NODE)
431 type = attr->children->content;
432 else if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
433 attr->children && attr->children->type == XML_TEXT_NODE)
435 value = attr->children->content;
441 *addinfo = "bad attribute for attr content";
448 *addinfo = "missing type attribute for att content";
454 *addinfo = "missing value attribute for att content";
458 *elem = (Z_AttributeElement *) odr_malloc(odr, sizeof(**elem));
460 (*elem)->attributeSet = yaz_str_to_z3950oid(odr, CLASS_ATTSET,
463 (*elem)->attributeSet = 0;
464 (*elem)->attributeType = intVal(odr, (const char *) type);
466 /* looks like a number ? */
467 for (i = 0; value[i] && value[i] >= '0' && value[i] <= '9'; i++)
469 if (num_values > 1 || value[i])
470 { /* multiple values or string, so turn to complex attribute */
471 (*elem)->which = Z_AttributeValue_complex;
472 (*elem)->value.complex =
473 (Z_ComplexAttribute*) odr_malloc(odr, sizeof(Z_ComplexAttribute));
474 (*elem)->value.complex->num_list = num_values;
475 (*elem)->value.complex->list = (Z_StringOrNumeric **)
476 odr_malloc(odr, sizeof(Z_StringOrNumeric*) * num_values);
478 /* second pass over attr values */
480 for (attr = ptr->properties; attr; attr = attr->next)
482 if (!xmlStrcmp(attr->name, BAD_CAST "value") &&
483 attr->children && attr->children->type == XML_TEXT_NODE)
485 const char *val = (const char *) attr->children->content;
486 assert (i < num_values);
487 (*elem)->value.complex->list[i] = (Z_StringOrNumeric *)
488 odr_malloc(odr, sizeof(Z_StringOrNumeric));
489 (*elem)->value.complex->list[i]->which =
490 Z_StringOrNumeric_string;
491 (*elem)->value.complex->list[i]->u.string =
492 odr_strdup(odr, val);
496 (*elem)->value.complex->num_semanticAction = 0;
497 (*elem)->value.complex->semanticAction = 0;
500 { /* good'ld numeric value */
501 (*elem)->which = Z_AttributeValue_numeric;
502 (*elem)->value.numeric = intVal(odr, (const char *) value);
506 char *strVal(const xmlNode *ptr_cdata, ODR odr)
512 for (ptr = ptr_cdata; ptr; ptr = ptr->next)
513 if (ptr->type == XML_TEXT_NODE)
514 len += xmlStrlen(ptr->content);
515 cdata = (char *) odr_malloc(odr, len+1);
517 for (ptr = ptr_cdata; ptr; ptr = ptr->next)
518 if (ptr->type == XML_TEXT_NODE)
519 strcat(cdata, (const char *) ptr->content);
523 void yaz_xml2query_term(const xmlNode *ptr,
524 Z_Term **term, ODR odr,
525 int *error_code, const char **addinfo)
528 struct _xmlAttr *attr;
529 char *cdata = strVal(ptr->children, odr);
531 for (attr = ptr->properties; attr; attr = attr->next)
533 if (!xmlStrcmp(attr->name, BAD_CAST "type") &&
534 attr->children && attr->children->type == XML_TEXT_NODE)
535 type = attr->children->content;
539 *addinfo = "bad attribute for attr content";
543 *term = (Z_Term *) odr_malloc(odr, sizeof(Z_Term));
545 if (!type || !xmlStrcmp(type, BAD_CAST "general"))
547 (*term)->which = Z_Term_general;
549 odr_create_Odr_oct(odr, (unsigned char *)cdata, strlen(cdata));
551 else if (!xmlStrcmp(type, BAD_CAST "numeric"))
553 (*term)->which = Z_Term_numeric;
554 (*term)->u.numeric = intVal(odr, cdata);
556 else if (!xmlStrcmp(type, BAD_CAST "string"))
558 (*term)->which = Z_Term_characterString;
559 (*term)->u.characterString = cdata;
561 else if (!xmlStrcmp(type, BAD_CAST "oid"))
564 *addinfo = "unhandled term type: oid";
566 else if (!xmlStrcmp(type, BAD_CAST "dateTime"))
569 *addinfo = "unhandled term type: dateTime";
571 else if (!xmlStrcmp(type, BAD_CAST "integerAndUnit"))
574 *addinfo = "unhandled term type: integerAndUnit";
576 else if (!xmlStrcmp(type, BAD_CAST "null"))
578 (*term)->which = Z_Term_null;
579 (*term)->u.null = odr_nullval();
584 *addinfo = "unhandled term type";
588 void yaz_xml2query_apt(const xmlNode *ptr_apt,
589 Z_AttributesPlusTerm **zapt, ODR odr,
590 int *error_code, const char **addinfo)
592 const xmlNode *ptr = ptr_apt->children;
595 *zapt = (Z_AttributesPlusTerm *)
596 odr_malloc(odr, sizeof(Z_AttributesPlusTerm));
598 /* deal with attributes */
599 (*zapt)->attributes = (Z_AttributeList*)
600 odr_malloc(odr, sizeof(Z_AttributeList));
602 /* how many attributes? */
603 for (; ptr; ptr = ptr->next)
604 if (ptr->type == XML_ELEMENT_NODE)
606 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
612 /* allocate and parse for real */
613 (*zapt)->attributes->num_attributes = num_attr;
614 (*zapt)->attributes->attributes = (Z_AttributeElement **)
615 odr_malloc(odr, sizeof(Z_AttributeElement*) * num_attr);
618 ptr = ptr_apt->children;
619 for (; ptr; ptr = ptr->next)
620 if (ptr->type == XML_ELEMENT_NODE)
622 if (!xmlStrcmp(ptr->name, BAD_CAST "attr"))
624 yaz_xml2query_attribute_element(
625 ptr, &(*zapt)->attributes->attributes[i], odr,
626 error_code, addinfo);
632 if (ptr && ptr->type == XML_ELEMENT_NODE)
634 if (!xmlStrcmp(ptr->name, BAD_CAST "term"))
637 yaz_xml2query_term(ptr, &(*zapt)->term, odr, error_code, addinfo);
642 *addinfo = "bad element in apt content";
648 *addinfo = "missing term node in apt content";
652 void yaz_xml2query_rset(const xmlNode *ptr, Z_ResultSetId **rset,
653 ODR odr, int *error_code, const char **addinfo)
657 *rset = strVal(ptr->children, odr);
662 *addinfo = "missing rset content";
666 void yaz_xml2query_rpnstructure(const xmlNode *ptr, Z_RPNStructure **zs,
667 ODR odr, int *error_code, const char **addinfo)
669 while (ptr && ptr->type != XML_ELEMENT_NODE)
672 if (!ptr || ptr->type != XML_ELEMENT_NODE)
675 *addinfo = "missing rpn structure node";
678 *zs = (Z_RPNStructure *) odr_malloc(odr, sizeof(Z_RPNStructure));
679 if (!xmlStrcmp(ptr->name, BAD_CAST "binary"))
681 Z_Complex *zc = odr_malloc(odr, sizeof(Z_Complex));
683 (*zs)->which = Z_RPNStructure_complex;
684 (*zs)->u.complex = zc;
686 yaz_xml2query_operator(ptr, &zc->roperator, odr, error_code, addinfo);
689 while (ptr && ptr->type != XML_ELEMENT_NODE)
691 yaz_xml2query_rpnstructure(ptr, &zc->s1, odr, error_code, addinfo);
694 while (ptr && ptr->type != XML_ELEMENT_NODE)
696 yaz_xml2query_rpnstructure(ptr, &zc->s2, odr, error_code, addinfo);
700 Z_Operand *s = (Z_Operand *) odr_malloc(odr, sizeof(Z_Operand));
701 (*zs)->which = Z_RPNStructure_simple;
703 if (!xmlStrcmp(ptr->name, BAD_CAST "apt"))
705 s->which = Z_Operand_APT;
706 yaz_xml2query_apt(ptr, &s->u.attributesPlusTerm,
707 odr, error_code, addinfo);
709 else if (!xmlStrcmp(ptr->name, BAD_CAST "rset"))
711 s->which = Z_Operand_resultSetId;
712 yaz_xml2query_rset(ptr, &s->u.resultSetId,
713 odr, error_code, addinfo);
718 *addinfo = "bad element: expected binary, apt or rset";
723 void yaz_xml2query_rpn(const xmlNode *ptr, Z_RPNQuery **query, ODR odr,
724 int *error_code, const char **addinfo)
726 const char *set = (const char *)
727 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "set");
729 *query = (Z_RPNQuery*) odr_malloc(odr, sizeof(Z_RPNQuery));
731 (*query)->attributeSetId = yaz_str_to_z3950oid(odr, CLASS_ATTSET, set);
733 (*query)->attributeSetId = 0;
734 yaz_xml2query_rpnstructure(ptr->children, &(*query)->RPNStructure,
735 odr, error_code, addinfo);
738 static void yaz_xml2query_(const xmlNode *ptr, Z_Query **query, ODR odr,
739 int *error_code, const char **addinfo)
741 if (ptr && ptr->type == XML_ELEMENT_NODE &&
742 !xmlStrcmp(ptr->name, BAD_CAST "query"))
744 const char *type = (const char *)
745 xmlGetProp((xmlNodePtr) ptr, BAD_CAST "type");
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 void *xmlnodep, Z_Query **query, ODR odr,
782 int *error_code, const char **addinfo)
784 return yaz_xml2query_(xmlnodep, query, odr, error_code, addinfo);
793 * indent-tabs-mode: nil
795 * vim: shiftwidth=4 tabstop=8 expandtab