Files in /opt/zorba (not /opt)
[mp-xquery-moved-to-github.git] / src / metaproxy_filter_xquery.cpp
1 /* This file is part of mp-xquery
2    Copyright (C) Index Data
3
4 Metaproxy is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Metaproxy is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17 */
18
19 #include <metaproxy/package.hpp>
20 #include <metaproxy/util.hpp>
21 #include <yaz/log.h>
22 #include <yaz/oid_db.h>
23 #include <yaz/diagbib1.h>
24 #include <map>
25 #include <string>
26 #include <iostream>
27 #include <fstream>
28 #include <sstream>
29
30 #include <zorba/zorba.h>
31 #include <zorba/store_manager.h>
32 #include <zorba/serializer.h>
33 #include <zorba/singleton_item_sequence.h>
34 #include <zorba/zorba_exception.h>
35
36
37 namespace mp = metaproxy_1;
38 namespace yf = mp::filter;
39 namespace mp_util = metaproxy_1::util;
40 using namespace mp;
41 using namespace zorba;
42
43 namespace metaproxy_1 {
44     namespace filter {
45         class XQuery : public Base {
46         public:
47             ~XQuery();
48             XQuery();
49             void process(metaproxy_1::Package & package) const;
50             void configure(const xmlNode * ptr, bool test_only,
51                            const char *path);
52             void start() const;
53             void stop(int signo) const;
54         private:
55             bool convert_one_record(const char *input_buf,
56                                     size_t input_len,
57                                     std::string &result) const;
58             std::map<std::string, std::string> zorba_variables;
59             std::string zorba_filename;
60             std::string zorba_script;
61             std::string zorba_record_variable;
62             Zorba *lZorba;
63             XQuery_t lQuery;
64         };
65     }
66 }
67
68 yf::XQuery::XQuery()
69 {
70     lZorba = 0;
71 }
72
73 yf::XQuery::~XQuery()
74 {
75     if (lZorba)
76         lZorba->shutdown();
77 }
78
79 void yf::XQuery::start() const
80 {
81 }
82
83 void yf::XQuery::stop(int signo) const
84 {
85 }
86
87 bool yf::XQuery::convert_one_record(const char *input_buf,
88                                     size_t input_len,
89                                     std::string &result) const
90 {
91     XQuery_t tQuery = lQuery->clone();
92
93     zorba::DynamicContext* lDynamicContext = tQuery->getDynamicContext();
94
95     zorba::Item lItem;
96     std::map<std::string, std::string>::const_iterator it;
97     for (it = zorba_variables.begin(); it != zorba_variables.end(); it++)
98     {
99         lItem = lZorba->getItemFactory()->createString(it->second);
100         lDynamicContext->setVariable(it->first, lItem);
101     }
102     std::string rec_content = "raw:" + std::string(input_buf, input_len);
103     lItem = lZorba->getItemFactory()->createString(rec_content);
104     lDynamicContext->setVariable(zorba_record_variable, lItem);
105
106     try {
107         std::stringstream ss;
108         tQuery->execute(ss);
109         result = ss.str();
110         return true;
111     } catch ( ZorbaException &e) {
112         result = e.what();
113         yaz_log(YLOG_WARN, "XQuery execute: %s", result.c_str());
114         return false;
115     }
116 }
117
118 void yf::XQuery::process(Package &package) const
119 {
120     Z_GDU *gdu_req = package.request().get();
121     Z_PresentRequest *pr_req = 0;
122     Z_SearchRequest *sr_req = 0;
123
124     const char *input_schema = 0;
125     Odr_oid *input_syntax = 0;
126
127     if (gdu_req && gdu_req->which == Z_GDU_Z3950 &&
128         gdu_req->u.z3950->which == Z_APDU_presentRequest)
129     {
130         pr_req = gdu_req->u.z3950->u.presentRequest;
131
132         input_schema =
133             mp_util::record_composition_to_esn(pr_req->recordComposition);
134         input_syntax = pr_req->preferredRecordSyntax;
135     }
136     else if (gdu_req && gdu_req->which == Z_GDU_Z3950 &&
137              gdu_req->u.z3950->which == Z_APDU_searchRequest)
138     {
139         sr_req = gdu_req->u.z3950->u.searchRequest;
140
141         input_syntax = sr_req->preferredRecordSyntax;
142
143         // we don't know how many hits we're going to get and therefore
144         // the effective element set name.. Therefore we can only allow
145         // two cases.. Both equal or absent.. If not, we'll just have to
146         // disable the piggyback!
147         if (sr_req->smallSetElementSetNames
148             &&
149             sr_req->mediumSetElementSetNames
150             &&
151             sr_req->smallSetElementSetNames->which == Z_ElementSetNames_generic
152             &&
153             sr_req->mediumSetElementSetNames->which == Z_ElementSetNames_generic
154             &&
155             !strcmp(sr_req->smallSetElementSetNames->u.generic,
156                     sr_req->mediumSetElementSetNames->u.generic))
157         {
158             input_schema = sr_req->smallSetElementSetNames->u.generic;
159         }
160         else if (!sr_req->smallSetElementSetNames &&
161                  !sr_req->mediumSetElementSetNames)
162             ; // input_schema is 0 already
163         else
164         {
165             // disable piggyback (perhaps it was disabled already)
166             *sr_req->smallSetUpperBound = 0;
167             *sr_req->largeSetLowerBound = 0;
168             *sr_req->mediumSetPresentNumber = 0;
169             package.move();
170             return;
171         }
172         // we can handle it in record_transform.
173     }
174     else
175     {
176         package.move();
177         return;
178     }
179
180     mp::odr odr_en(ODR_ENCODE);
181
182     const char *backend_schema = 0;
183     const Odr_oid *backend_syntax = 0;
184
185     if (input_schema && !strcmp(input_schema, "bibframe") &&
186         (!input_syntax || !oid_oidcmp(input_syntax, yaz_oid_recsyn_xml)))
187     {
188         backend_schema = "marcxml";
189         backend_syntax = yaz_oid_recsyn_xml;
190     }
191     else
192     {
193         package.move();
194         return;
195     }
196
197     if (sr_req)
198     {
199         if (backend_syntax)
200             sr_req->preferredRecordSyntax = odr_oiddup(odr_en, backend_syntax);
201         else
202             sr_req->preferredRecordSyntax = 0;
203         if (backend_schema)
204         {
205             sr_req->smallSetElementSetNames
206                 = (Z_ElementSetNames *)
207                 odr_malloc(odr_en, sizeof(Z_ElementSetNames));
208             sr_req->smallSetElementSetNames->which = Z_ElementSetNames_generic;
209             sr_req->smallSetElementSetNames->u.generic
210                 = odr_strdup(odr_en, backend_schema);
211             sr_req->mediumSetElementSetNames = sr_req->smallSetElementSetNames;
212         }
213         else
214         {
215             sr_req->smallSetElementSetNames = 0;
216             sr_req->mediumSetElementSetNames = 0;
217         }
218     }
219     else if (pr_req)
220     {
221         if (backend_syntax)
222             pr_req->preferredRecordSyntax = odr_oiddup(odr_en, backend_syntax);
223         else
224             pr_req->preferredRecordSyntax = 0;
225
226         if (backend_schema)
227         {
228             pr_req->recordComposition
229                 = (Z_RecordComposition *)
230                 odr_malloc(odr_en, sizeof(Z_RecordComposition));
231             pr_req->recordComposition->which
232                 = Z_RecordComp_simple;
233             pr_req->recordComposition->u.simple
234                 = (Z_ElementSetNames *)
235                 odr_malloc(odr_en, sizeof(Z_ElementSetNames));
236             pr_req->recordComposition->u.simple->which = Z_ElementSetNames_generic;
237             pr_req->recordComposition->u.simple->u.generic
238                 = odr_strdup(odr_en, backend_schema);
239         }
240         else
241             pr_req->recordComposition = 0;
242     }
243     package.move();
244
245     Z_GDU *gdu_res = package.response().get();
246
247     // see if we have a records list to patch!
248     Z_NamePlusRecordList *records = 0;
249     if (gdu_res && gdu_res->which == Z_GDU_Z3950 &&
250         gdu_res->u.z3950->which == Z_APDU_presentResponse)
251     {
252         Z_PresentResponse * pr_res = gdu_res->u.z3950->u.presentResponse;
253
254         if (pr_res
255             && pr_res->numberOfRecordsReturned
256             && *(pr_res->numberOfRecordsReturned) > 0
257             && pr_res->records
258             && pr_res->records->which == Z_Records_DBOSD)
259         {
260             records = pr_res->records->u.databaseOrSurDiagnostics;
261         }
262     }
263     if (gdu_res && gdu_res->which == Z_GDU_Z3950 &&
264         gdu_res->u.z3950->which == Z_APDU_searchResponse)
265     {
266         Z_SearchResponse *sr_res = gdu_res->u.z3950->u.searchResponse;
267
268         if (sr_res
269             && sr_res->numberOfRecordsReturned
270             && *(sr_res->numberOfRecordsReturned) > 0
271             && sr_res->records
272             && sr_res->records->which == Z_Records_DBOSD)
273         {
274             records = sr_res->records->u.databaseOrSurDiagnostics;
275         }
276     }
277     if (records)
278     {
279         int i;
280         for (i = 0; i < records->num_records; i++)
281         {
282             Z_NamePlusRecord **npr = &records->records[i];
283             if ((*npr)->which == Z_NamePlusRecord_databaseRecord)
284             {
285                 const char *details = 0;
286                 Z_External *r = (*npr)->u.databaseRecord;
287                 int ret_trans = -1;
288                 if (r->which == Z_External_octet &&
289                     !oid_oidcmp(r->direct_reference, yaz_oid_recsyn_xml))
290                 {
291                     std::string result;
292                     if (convert_one_record(
293                         r->u.octet_aligned->buf, r->u.octet_aligned->len,
294                         result))
295                     {
296                         (*npr)->u.databaseRecord =
297                             z_ext_record_oid(odr_en, yaz_oid_recsyn_xml,
298                                              result.c_str(),
299                                              result.length());
300                     }
301                     else
302                     {
303                         *npr = zget_surrogateDiagRec(
304                             odr_en, (*npr)->databaseName,
305                             YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
306                             result.c_str());
307                     }
308                 }
309             }
310         }
311         package.response() = gdu_res;
312     }
313 }
314
315 void yf::XQuery::configure(const xmlNode * ptr, bool test_only,
316                            const char *path)
317 {
318     for (ptr = ptr->children; ptr; ptr = ptr->next)
319     {
320         if (ptr->type != XML_ELEMENT_NODE)
321             continue;
322         if (!strcmp((const char *) ptr->name, "setVariable"))
323         {
324             std::string name;
325             std::string value;
326             struct _xmlAttr *attr;
327             for (attr = ptr->properties; attr; attr = attr->next)
328                 if (!strcmp((const char *) attr->name, "name"))
329                     name = mp::xml::get_text(attr->children);
330                 else if (!strcmp((const char *) attr->name, "value"))
331                     value = mp::xml::get_text(attr->children);
332                 else
333                     throw mp::filter::FilterException(
334                         "Bad attribute " + std::string((const char *)
335                                                        attr->name));
336             if (name.length() > 0)
337                 zorba_variables[name] = value;
338         }
339         else if (!strcmp((const char *) ptr->name, "script"))
340         {
341             std::string value;
342             struct _xmlAttr *attr;
343             for (attr = ptr->properties; attr; attr = attr->next)
344                 if (!strcmp((const char *) attr->name, "value"))
345                     value = mp::xml::get_text(attr->children);
346                 else
347                     throw mp::filter::FilterException(
348                         "Bad attribute " + std::string((const char *)
349                                                        attr->name));
350             zorba_script = value;
351         }
352         else if (!strcmp((const char *) ptr->name, "record"))
353         {
354             std::string value;
355             struct _xmlAttr *attr;
356             for (attr = ptr->properties; attr; attr = attr->next)
357                 if (!strcmp((const char *) attr->name, "value"))
358                     value = mp::xml::get_text(attr->children);
359                 else
360                     throw mp::filter::FilterException(
361                         "Bad attribute " + std::string((const char *)
362                                                        attr->name));
363             zorba_record_variable = value;
364         }
365         else
366         {
367             throw mp::filter::FilterException("Bad element "
368                                                + std::string((const char *)
369                                                              ptr->name));
370         }
371     }
372     if (zorba_script.length() == 0)
373         throw mp::filter::FilterException("Missing element script");
374     if (zorba_record_variable.length() == 0)
375         throw mp::filter::FilterException("Missing element record");
376     if (!test_only)
377     {
378         void* lStore = StoreManager::getStore();
379         lZorba = Zorba::getInstance(lStore);
380
381         lQuery = lZorba->createQuery();
382
383         try {
384             size_t t = zorba_script.find_last_of('/');
385             if (t != std::string::npos)
386                 lQuery->setFileName(zorba_script.substr(0, t + 1));
387             std::unique_ptr<std::istream> qfile(
388                 new std::ifstream(zorba_script.c_str()));
389             Zorba_CompilerHints lHints;
390             lQuery->compile(*qfile, lHints);
391         } catch ( ZorbaException &e) {
392             std::string msg = "XQuery compile: ";
393             msg += e.what();
394             throw mp::filter::FilterException(msg);
395         }
396     }
397 }
398
399 static yf::Base* filter_creator()
400 {
401     return new mp::filter::XQuery;
402 }
403
404 extern "C" {
405     struct metaproxy_1_filter_struct metaproxy_1_filter_xquery = {
406         0,
407         "xquery",
408         filter_creator
409     };
410 }
411
412
413 /*
414  * Local variables:
415  * c-basic-offset: 4
416  * c-file-style: "Stroustrup"
417  * indent-tabs-mode: nil
418  * End:
419  * vim: shiftwidth=4 tabstop=8 expandtab
420  */
421