src/filter_sparql.cpp

   1 /* This file is part of Metaproxy.
   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/srw.h>
  23 #include <yaz/diagbib1.h>
  24 #include <yaz/match_glob.h>
  25 #include <boost/scoped_ptr.hpp>
  26 #include <boost/thread/mutex.hpp>
  27 #include <boost/thread/condition.hpp>
  28 #include <boost/algorithm/string.hpp>
  29 #include "sparql.h"
  30
  31 #include <yaz/zgdu.h>
  32
  33 namespace mp = metaproxy_1;
  34 namespace yf = mp::filter;
  35
  36 namespace metaproxy_1 {
  37     namespace filter {
  38         class SPARQL : public Base {
  39             class Session;
  40             class Rep;
  41             class Conf;
  42             class Result;
  43             class FrontendSet;
  44
  45             typedef boost::shared_ptr<Session> SessionPtr;
  46             typedef boost::shared_ptr<Conf> ConfPtr;
  47
  48             typedef boost::shared_ptr<FrontendSet> FrontendSetPtr;
  49             typedef std::map<std::string,FrontendSetPtr> FrontendSets;
  50         public:
  51             SPARQL();
  52             ~SPARQL();
  53             void process(metaproxy_1::Package & package) const;
  54             void configure(const xmlNode * ptr, bool test_only,
  55                            const char *path);
  56             SessionPtr get_session(Package &package, Z_APDU **apdu) const;
  57             void release_session(Package &package) const;
  58             boost::scoped_ptr<Rep> m_p;
  59             std::list<ConfPtr> db_conf;
  60         };
  61         class SPARQL::Conf {
  62         public:
  63             std::string db;
  64             std::string uri;
  65             std::string schema;
  66             yaz_sparql_t s;
  67             ~Conf();
  68         };
  69         class SPARQL::Rep {
  70             friend class SPARQL;
  71             boost::condition m_cond_session_ready;
  72             boost::mutex m_mutex;
  73             std::map<mp::Session,SessionPtr> m_clients;
  74         };
  75         class SPARQL::Result {
  76         public:
  77             Result();
  78             ~Result();
  79         private:
  80             friend class FrontendSet;
  81             friend class Session;
  82             ConfPtr conf;
  83             xmlDoc *doc;
  84         };
  85         class SPARQL::FrontendSet {
  86         private:
  87             friend class Session;
  88             Odr_int hits;
  89             std::string db;
  90             std::list<Result> results;
  91         };
  92         class SPARQL::Session {
  93         public:
  94             Session(const SPARQL *);
  95             ~Session();
  96             void handle_z(Package &package, Z_APDU *apdu);
  97             Z_APDU *search(mp::Package &package,
  98                            Z_APDU *apdu_req,
  99                            mp::odr &odr,
 100                            const char *sparql_query,
 101                            ConfPtr conf, FrontendSetPtr fset);
 102             int invoke_sparql(mp::Package &package,
 103                               const char *sparql_query,
 104                               ConfPtr conf,
 105                               WRBUF w);
 106
 107             Z_Records *fetch(
 108                 Package &package,
 109                 FrontendSetPtr fset,
 110                 ODR odr, Odr_oid *preferredRecordSyntax,
 111                 Z_ElementSetNames *esn,
 112                 int start, int number, int &error_code, std::string &addinfo,
 113                 int *number_returned, int *next_position);
 114             bool m_in_use;
 115         private:
 116             bool m_support_named_result_sets;
 117             FrontendSets m_frontend_sets;
 118             const SPARQL *m_sparql;
 119         };
 120     }
 121 }
 122
 123 yf::SPARQL::Result::~Result()
 124 {
 125     if (doc)
 126         xmlFreeDoc(doc);
 127 }
 128
 129 yf::SPARQL::Result::Result()
 130 {
 131     doc = 0;
 132 }
 133
 134 yf::SPARQL::SPARQL() : m_p(new Rep)
 135 {
 136 }
 137
 138 yf::SPARQL::~SPARQL()
 139 {
 140 }
 141
 142 void yf::SPARQL::configure(const xmlNode *xmlnode, bool test_only,
 143                            const char *path)
 144 {
 145     const xmlNode *ptr = xmlnode->children;
 146     std::string uri;
 147
 148     for (; ptr; ptr = ptr->next)
 149     {
 150         if (ptr->type != XML_ELEMENT_NODE)
 151             continue;
 152         if (!strcmp((const char *) ptr->name, "defaults"))
 153         {
 154             const struct _xmlAttr *attr;
 155             for (attr = ptr->properties; attr; attr = attr->next)
 156             {
 157                 if (!strcmp((const char *) attr->name, "uri"))
 158                     uri = mp::xml::get_text(attr->children);
 159                 else
 160                     throw mp::filter::FilterException(
 161                         "Bad attribute " + std::string((const char *)
 162                                                        attr->name));
 163             }
 164         }
 165         else if (!strcmp((const char *) ptr->name, "db"))
 166         {
 167             yaz_sparql_t s = yaz_sparql_create();
 168             ConfPtr conf(new Conf);
 169             conf->s = s;
 170             conf->uri = uri;
 171
 172             const struct _xmlAttr *attr;
 173             for (attr = ptr->properties; attr; attr = attr->next)
 174             {
 175                 if (!strcmp((const char *) attr->name, "path"))
 176                     conf->db = mp::xml::get_text(attr->children);
 177                 else if (!strcmp((const char *) attr->name, "uri"))
 178                     conf->uri = mp::xml::get_text(attr->children);
 179                 else if (!strcmp((const char *) attr->name, "schema"))
 180                     conf->schema = mp::xml::get_text(attr->children);
 181                 else if (!strcmp((const char *) attr->name, "include"))
 182                 {
 183                     std::vector<std::string> dbs;
 184                     std::string db = mp::xml::get_text(attr->children);
 185                     boost::split(dbs, db, boost::is_any_of(" \t"));
 186                     size_t i;
 187                     for (i = 0; i < dbs.size(); i++)
 188                     {
 189                         if (dbs[i].length() == 0)
 190                             continue;
 191                         std::list<ConfPtr>::const_iterator it = db_conf.begin();
 192                         while (1)
 193                             if (it == db_conf.end())
 194                             {
 195                                 throw mp::filter::FilterException(
 196                                     "include db not found: " + dbs[i]);
 197                             }
 198                             else if (dbs[i].compare((*it)->db) == 0)
 199                             {
 200                                 yaz_sparql_include(s, (*it)->s);
 201                                 break;
 202                             }
 203                             else
 204                                 it++;
 205                     }
 206                 }
 207                 else
 208                     throw mp::filter::FilterException(
 209                         "Bad attribute " + std::string((const char *)
 210                                                        attr->name));
 211             }
 212             xmlNode *p = ptr->children;
 213             for (; p; p = p->next)
 214             {
 215                 if (p->type != XML_ELEMENT_NODE)
 216                     continue;
 217                 std::string name = (const char *) p->name;
 218                 const struct _xmlAttr *attr;
 219                 for (attr = p->properties; attr; attr = attr->next)
 220                 {
 221                     if (!strcmp((const char *) attr->name, "type"))
 222                     {
 223                         name.append(".");
 224                         name.append(mp::xml::get_text(attr->children));
 225                     }
 226                     else
 227                         throw mp::filter::FilterException(
 228                             "Bad attribute " + std::string((const char *)
 229                                                            attr->name));
 230                 }
 231                 std::string value = mp::xml::get_text(p);
 232                 if (yaz_sparql_add_pattern(s, name.c_str(), value.c_str()))
 233                 {
 234                     throw mp::filter::FilterException(
 235                         "Bad SPARQL config " + name);
 236                 }
 237             }
 238             if (!conf->uri.length())
 239             {
 240                 throw mp::filter::FilterException("Missing uri");
 241             }
 242             if (!conf->db.length())
 243             {
 244                 throw mp::filter::FilterException("Missing path");
 245             }
 246             db_conf.push_back(conf);
 247         }
 248         else
 249         {
 250             throw mp::filter::FilterException
 251                 ("Bad element "
 252                  + std::string((const char *) ptr->name)
 253                  + " in sparql filter");
 254         }
 255     }
 256 }
 257
 258 yf::SPARQL::Conf::~Conf()
 259 {
 260     yaz_sparql_destroy(s);
 261 }
 262
 263 yf::SPARQL::Session::Session(const SPARQL *sparql) :
 264     m_in_use(true),
 265     m_support_named_result_sets(false),
 266     m_sparql(sparql)
 267 {
 268 }
 269
 270 yf::SPARQL::Session::~Session()
 271 {
 272 }
 273
 274 yf::SPARQL::SessionPtr yf::SPARQL::get_session(Package & package,
 275                                                Z_APDU **apdu) const
 276 {
 277     SessionPtr ptr0;
 278
 279     Z_GDU *gdu = package.request().get();
 280
 281     boost::mutex::scoped_lock lock(m_p->m_mutex);
 282
 283     std::map<mp::Session,SPARQL::SessionPtr>::iterator it;
 284
 285     if (gdu && gdu->which == Z_GDU_Z3950)
 286         *apdu = gdu->u.z3950;
 287     else
 288         *apdu = 0;
 289
 290     while (true)
 291     {
 292         it = m_p->m_clients.find(package.session());
 293         if (it == m_p->m_clients.end())
 294             break;
 295         if (!it->second->m_in_use)
 296         {
 297             it->second->m_in_use = true;
 298             return it->second;
 299         }
 300         m_p->m_cond_session_ready.wait(lock);
 301     }
 302     if (!*apdu)
 303         return ptr0;
 304
 305     // new Z39.50 session ..
 306     SessionPtr p(new Session(this));
 307     m_p->m_clients[package.session()] = p;
 308     return p;
 309 }
 310
 311 void yf::SPARQL::release_session(Package &package) const
 312 {
 313     boost::mutex::scoped_lock lock(m_p->m_mutex);
 314     std::map<mp::Session,SessionPtr>::iterator it;
 315
 316     it = m_p->m_clients.find(package.session());
 317     if (it != m_p->m_clients.end())
 318     {
 319         it->second->m_in_use = false;
 320
 321         if (package.session().is_closed())
 322             m_p->m_clients.erase(it);
 323         m_p->m_cond_session_ready.notify_all();
 324     }
 325 }
 326
 327 static bool get_result(xmlDoc *doc, Odr_int *sz, Odr_int pos, xmlDoc **ndoc)
 328 {
 329     xmlNode *ptr = xmlDocGetRootElement(doc);
 330     xmlNode *q0;
 331     Odr_int cur = 0;
 332
 333     if (ndoc)
 334         *ndoc = xmlNewDoc(BAD_CAST "1.0");
 335
 336     if (ptr->type == XML_ELEMENT_NODE &&
 337         !strcmp((const char *) ptr->name, "RDF"))
 338     {
 339         if (ndoc)
 340         {
 341             q0 = xmlCopyNode(ptr, 2);
 342             xmlDocSetRootElement(*ndoc, q0);
 343         }
 344         ptr = ptr->children;
 345
 346         while (ptr && ptr->type != XML_ELEMENT_NODE)
 347             ptr = ptr->next;
 348         if (ptr && ptr->type == XML_ELEMENT_NODE &&
 349             !strcmp((const char *) ptr->name, "Description"))
 350         {
 351             xmlNode *p = ptr->children;
 352
 353             while (p && p->type != XML_ELEMENT_NODE)
 354                 p = p->next;
 355             if (p && p->type == XML_ELEMENT_NODE &&
 356                 !strcmp((const char *) p->name, "type"))
 357             { /* SELECT RESULT */
 358                 for (ptr = ptr->children; ptr; ptr = ptr->next)
 359                     if (ptr->type == XML_ELEMENT_NODE &&
 360                         !strcmp((const char *) ptr->name, "solution"))
 361                     {
 362                         if (cur++ == pos)
 363                         {
 364                             if (ndoc)
 365                             {
 366                                 xmlNode *q1 = xmlCopyNode(ptr, 1);
 367                                 xmlAddChild(q0, q1);
 368                             }
 369                             break;
 370                         }
 371                     }
 372             }
 373             else
 374             {   /* CONSTRUCT result */
 375                 for (; ptr; ptr = ptr->next)
 376                     if (ptr->type == XML_ELEMENT_NODE &&
 377                         !strcmp((const char *) ptr->name, "Description"))
 378                     {
 379                         if (cur++ == pos)
 380                         {
 381                             if (ndoc)
 382                             {
 383                                 xmlNode *q1 = xmlCopyNode(ptr, 1);
 384                                 xmlAddChild(q0, q1);
 385                             }
 386                             return true;
 387                         }
 388                     }
 389             }
 390         }
 391     }
 392     else
 393     {
 394         for (; ptr; ptr = ptr->next)
 395             if (ptr->type == XML_ELEMENT_NODE &&
 396                 !strcmp((const char *) ptr->name, "sparql"))
 397                 break;
 398         if (ptr)
 399         {
 400             if (ndoc)
 401             {
 402                 q0 = xmlCopyNode(ptr, 2);
 403                 xmlDocSetRootElement(*ndoc, q0);
 404             }
 405             for (ptr = ptr->children; ptr; ptr = ptr->next)
 406                 if (ptr->type == XML_ELEMENT_NODE &&
 407                     !strcmp((const char *) ptr->name, "results"))
 408                     break;
 409         }
 410         if (ptr)
 411         {
 412             xmlNode *q1 = 0;
 413             if (ndoc)
 414             {
 415                 q1 = xmlCopyNode(ptr, 0);
 416                 xmlAddChild(q0, q1);
 417             }
 418             for (ptr = ptr->children; ptr; ptr = ptr->next)
 419                 if (ptr->type == XML_ELEMENT_NODE &&
 420                     !strcmp((const char *) ptr->name, "result"))
 421                 {
 422                     if (cur++ == pos)
 423                     {
 424                         if (ndoc)
 425                         {
 426                             xmlNode *q2 = xmlCopyNode(ptr, 1);
 427                             xmlAddChild(q1, q2);
 428                         }
 429                         return true;
 430                     }
 431                 }
 432         }
 433     }
 434     if (sz)
 435         *sz = cur;
 436     return false;
 437 }
 438
 439 Z_Records *yf::SPARQL::Session::fetch(
 440     Package &package,
 441     FrontendSetPtr fset,
 442     ODR odr, Odr_oid *preferredRecordSyntax,
 443     Z_ElementSetNames *esn,
 444     int start, int number, int &error_code, std::string &addinfo,
 445     int *number_returned, int *next_position)
 446 {
 447     Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 448     std::list<Result>::iterator it = fset->results.begin();
 449     const char *schema = 0;
 450     bool uri_lookup = false;
 451     if (esn && esn->which == Z_ElementSetNames_generic)
 452         schema = esn->u.generic;
 453
 454     for (; it != fset->results.end(); it++)
 455     {
 456         if (yaz_sparql_lookup_schema(it->conf->s, schema))
 457         {
 458             uri_lookup = true;
 459             break;
 460         }
 461         if (!schema || !strcmp(esn->u.generic, it->conf->schema.c_str()))
 462             break;
 463     }
 464     if (it == fset->results.end())
 465     {
 466         rec->which = Z_Records_NSD;
 467         rec->u.nonSurrogateDiagnostic =
 468             zget_DefaultDiagFormat(
 469                 odr,
 470                 YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_,
 471                 schema);
 472         return rec;
 473     }
 474     rec->which = Z_Records_DBOSD;
 475     rec->u.databaseOrSurDiagnostics = (Z_NamePlusRecordList *)
 476         odr_malloc(odr, sizeof(Z_NamePlusRecordList));
 477     rec->u.databaseOrSurDiagnostics->records = (Z_NamePlusRecord **)
 478         odr_malloc(odr, sizeof(Z_NamePlusRecord *) * number);
 479     int i;
 480     for (i = 0; i < number; i++)
 481     {
 482         rec->u.databaseOrSurDiagnostics->records[i] = (Z_NamePlusRecord *)
 483             odr_malloc(odr, sizeof(Z_NamePlusRecord));
 484         Z_NamePlusRecord *npr = rec->u.databaseOrSurDiagnostics->records[i];
 485         npr->databaseName = odr_strdup(odr, fset->db.c_str());
 486         npr->which = Z_NamePlusRecord_databaseRecord;
 487         xmlDoc *ndoc = 0;
 488
 489         if (!get_result(it->doc, 0, start - 1 + i, &ndoc))
 490         {
 491             if (ndoc)
 492                 xmlFreeDoc(ndoc);
 493             break;
 494         }
 495         xmlNode *ndoc_root = xmlDocGetRootElement(ndoc);
 496         if (!ndoc_root)
 497         {
 498             xmlFreeDoc(ndoc);
 499             break;
 500         }
 501         if (uri_lookup)
 502         {
 503             std::string uri;
 504             xmlNode *n = ndoc_root;
 505             while (n)
 506             {
 507                 if (n->type == XML_ELEMENT_NODE)
 508                 {
 509                     if (!strcmp((const char *) n->name, "uri"))
 510                     {
 511                         uri = mp::xml::get_text(n->children);
 512
 513                     }
 514                     n = n->children;
 515                 }
 516                 else
 517                     n = n->next;
 518             }
 519             if (!uri.length())
 520             {
 521                 rec->which = Z_Records_NSD;
 522                 rec->u.nonSurrogateDiagnostic =
 523                     zget_DefaultDiagFormat(
 524                         odr,
 525                         YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS, 0);
 526                 xmlFreeDoc(ndoc);
 527                 return rec;
 528             }
 529             else
 530             {
 531                 mp::wrbuf addinfo, query, w;
 532                 int error = yaz_sparql_from_uri_wrbuf(it->conf->s,
 533                                                       addinfo, query,
 534                                                       uri.c_str(), schema);
 535                 if (!error)
 536                 {
 537                     yaz_log(YLOG_LOG, "query=%s", query.c_str());
 538                     error = invoke_sparql(package, query.c_str(),
 539                                           it->conf, w);
 540                 }
 541                 if (error)
 542                 {
 543                     rec->which = Z_Records_NSD;
 544                     rec->u.nonSurrogateDiagnostic =
 545                         zget_DefaultDiagFormat(
 546                             odr,
 547                             error,
 548                             addinfo.len() ? addinfo.c_str() : 0);
 549                     xmlFreeDoc(ndoc);
 550                     return rec;
 551                 }
 552                 npr->u.databaseRecord =
 553                     z_ext_record_xml(odr, w.c_str(), w.len());
 554             }
 555         }
 556         else
 557         {
 558             xmlBufferPtr buf = xmlBufferCreate();
 559             xmlNodeDump(buf, ndoc, ndoc_root, 0, 0);
 560             yaz_log(YLOG_LOG, "record %s %.*s", uri_lookup ? "uri" : "normal",
 561                     (int) buf->use, (const char *) buf->content);
 562             npr->u.databaseRecord =
 563                 z_ext_record_xml(odr, (const char *) buf->content, buf->use);
 564             xmlBufferFree(buf);
 565         }
 566         xmlFreeDoc(ndoc);
 567     }
 568     rec->u.databaseOrSurDiagnostics->num_records = i;
 569     *number_returned = i;
 570     if (start + number > fset->hits)
 571         *next_position = 0;
 572     else
 573         *next_position = start + number;
 574     return rec;
 575 }
 576
 577 int yf::SPARQL::Session::invoke_sparql(mp::Package &package,
 578                                        const char *sparql_query,
 579                                        ConfPtr conf,
 580                                        WRBUF w)
 581 {
 582     Package http_package(package.session(), package.origin());
 583     mp::odr odr;
 584
 585     http_package.copy_filter(package);
 586     Z_GDU *gdu = z_get_HTTP_Request_uri(odr, conf->uri.c_str(), 0, 1);
 587
 588     z_HTTP_header_add(odr, &gdu->u.HTTP_Request->headers,
 589                       "Content-Type", "application/x-www-form-urlencoded");
 590     z_HTTP_header_add(odr, &gdu->u.HTTP_Request->headers,
 591                       "Accept", "application/sparql-results+xml,"
 592                       "application/rdf+xml");
 593     const char *names[2];
 594     names[0] = "query";
 595     names[1] = 0;
 596     const char *values[1];
 597     values[0] = sparql_query;
 598     char *path = 0;
 599     yaz_array_to_uri(&path, odr, (char **) names, (char **) values);
 600
 601     gdu->u.HTTP_Request->content_buf = path;
 602     gdu->u.HTTP_Request->content_len = strlen(path);
 603
 604     yaz_log(YLOG_LOG, "sparql: HTTP request\n%s", sparql_query);
 605
 606     http_package.request() = gdu;
 607     http_package.move();
 608
 609     Z_GDU *gdu_resp = http_package.response().get();
 610
 611     if (!gdu_resp || gdu_resp->which != Z_GDU_HTTP_Response)
 612     {
 613         wrbuf_puts(w, "no HTTP response from backend");
 614         return YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
 615     }
 616     else if (gdu_resp->u.HTTP_Response->code != 200)
 617     {
 618         wrbuf_printf(w, "sparql: HTTP error %d from backend",
 619                      gdu_resp->u.HTTP_Response->code);
 620         return YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
 621     }
 622     Z_HTTP_Response *resp = gdu_resp->u.HTTP_Response;
 623     wrbuf_write(w, resp->content_buf, resp->content_len);
 624     return 0;
 625 }
 626
 627 Z_APDU *yf::SPARQL::Session::search(mp::Package &package,
 628                                     Z_APDU *apdu_req,
 629                                     mp::odr &odr,
 630                                     const char *sparql_query,
 631                                     ConfPtr conf, FrontendSetPtr fset)
 632 {
 633     Z_SearchRequest *req = apdu_req->u.searchRequest;
 634     Z_APDU *apdu_res = 0;
 635     mp::wrbuf w;
 636
 637     int error = invoke_sparql(package, sparql_query, conf, w);
 638     if (error)
 639     {
 640         apdu_res = odr.create_searchResponse(apdu_req, error,
 641                                              w.len() ?
 642                                              w.c_str() : 0);
 643     }
 644     else
 645     {
 646         xmlDocPtr doc = xmlParseMemory(w.c_str(), w.len());
 647         if (!doc)
 648         {
 649             apdu_res = odr.create_searchResponse(
 650                 apdu_req,
 651                 YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
 652                 "invalid XML from backendbackend");
 653         }
 654         else
 655         {
 656             Result result;
 657             Z_Records *records = 0;
 658             int number_returned = 0;
 659             int next_position = 0;
 660             int error_code = 0;
 661             std::string addinfo;
 662
 663             result.doc = doc;
 664             result.conf = conf;
 665             fset->results.push_back(result);
 666             yaz_log(YLOG_LOG, "saving sparql result xmldoc=%p", doc);
 667
 668             get_result(result.doc, &fset->hits, -1, 0);
 669             m_frontend_sets[req->resultSetName] = fset;
 670
 671             result.doc = 0;
 672
 673             Odr_int number = 0;
 674             const char *element_set_name = 0;
 675             mp::util::piggyback_sr(req, fset->hits, number, &element_set_name);
 676             if (number)
 677             {
 678                 Z_ElementSetNames *esn;
 679
 680                 if (number > *req->smallSetUpperBound)
 681                     esn = req->mediumSetElementSetNames;
 682                 else
 683                     esn = req->smallSetElementSetNames;
 684                 records = fetch(package, fset,
 685                                 odr, req->preferredRecordSyntax, esn,
 686                                 1, number,
 687                                 error_code, addinfo,
 688                                 &number_returned,
 689                                 &next_position);
 690             }
 691             if (error_code)
 692             {
 693                 apdu_res =
 694                     odr.create_searchResponse(
 695                         apdu_req, error_code, addinfo.c_str());
 696             }
 697             else
 698             {
 699                 apdu_res =
 700                     odr.create_searchResponse(apdu_req, 0, 0);
 701                 Z_SearchResponse *resp = apdu_res->u.searchResponse;
 702                 *resp->resultCount = fset->hits;
 703                 *resp->numberOfRecordsReturned = number_returned;
 704                 *resp->nextResultSetPosition = next_position;
 705                 resp->records = records;
 706             }
 707         }
 708     }
 709     return apdu_res;
 710 }
 711
 712 void yf::SPARQL::Session::handle_z(mp::Package &package, Z_APDU *apdu_req)
 713 {
 714     mp::odr odr;
 715     Z_APDU *apdu_res = 0;
 716     if (apdu_req->which == Z_APDU_initRequest)
 717     {
 718         apdu_res = odr.create_initResponse(apdu_req, 0, 0);
 719         Z_InitRequest *req = apdu_req->u.initRequest;
 720         Z_InitResponse *resp = apdu_res->u.initResponse;
 721
 722         resp->implementationName = odr_strdup(odr, "sparql");
 723         if (ODR_MASK_GET(req->options, Z_Options_namedResultSets))
 724             m_support_named_result_sets = true;
 725         int i;
 726         static const int masks[] = {
 727             Z_Options_search, Z_Options_present,
 728             Z_Options_namedResultSets, -1
 729         };
 730         for (i = 0; masks[i] != -1; i++)
 731             if (ODR_MASK_GET(req->options, masks[i]))
 732                 ODR_MASK_SET(resp->options, masks[i]);
 733         static const int versions[] = {
 734             Z_ProtocolVersion_1,
 735             Z_ProtocolVersion_2,
 736             Z_ProtocolVersion_3,
 737             -1
 738         };
 739         for (i = 0; versions[i] != -1; i++)
 740             if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 741                 ODR_MASK_SET(resp->protocolVersion, versions[i]);
 742             else
 743                 break;
 744         *resp->preferredMessageSize = *req->preferredMessageSize;
 745         *resp->maximumRecordSize = *req->maximumRecordSize;
 746     }
 747     else if (apdu_req->which == Z_APDU_close)
 748     {
 749         apdu_res = odr.create_close(apdu_req,
 750                                     Z_Close_finished, 0);
 751         package.session().close();
 752     }
 753     else if (apdu_req->which == Z_APDU_searchRequest)
 754     {
 755         Z_SearchRequest *req = apdu_req->u.searchRequest;
 756
 757         FrontendSets::iterator fset_it =
 758             m_frontend_sets.find(req->resultSetName);
 759         if (fset_it != m_frontend_sets.end())
 760         {
 761             // result set already exist
 762             // if replace indicator is off: we return diagnostic if
 763             // result set already exist.
 764             if (*req->replaceIndicator == 0)
 765             {
 766                 Z_APDU *apdu =
 767                     odr.create_searchResponse(
 768                         apdu_req,
 769                         YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 770                         0);
 771                 package.response() = apdu;
 772             }
 773             m_frontend_sets.erase(fset_it);
 774         }
 775         if (req->query->which != Z_Query_type_1)
 776         {
 777             apdu_res = odr.create_searchResponse(
 778                 apdu_req, YAZ_BIB1_QUERY_TYPE_UNSUPP, 0);
 779         }
 780         else if (req->num_databaseNames != 1)
 781         {
 782             apdu_res = odr.create_searchResponse(
 783                 apdu_req,
 784                 YAZ_BIB1_ACCESS_TO_SPECIFIED_DATABASE_DENIED, 0);
 785         }
 786         else
 787         {
 788             std::string db = req->databaseNames[0];
 789             std::list<ConfPtr>::const_iterator it;
 790             FrontendSetPtr fset(new FrontendSet);
 791
 792             m_frontend_sets.erase(req->resultSetName);
 793             fset->db = db;
 794             it = m_sparql->db_conf.begin();
 795             for (; it != m_sparql->db_conf.end(); it++)
 796                 if ((*it)->schema.length() > 0
 797                     && yaz_match_glob((*it)->db.c_str(), db.c_str()))
 798                 {
 799                     mp::wrbuf addinfo_wr;
 800                     mp::wrbuf sparql_wr;
 801                     int error =
 802                         yaz_sparql_from_rpn_wrbuf((*it)->s,
 803                                                   addinfo_wr, sparql_wr,
 804                                                   req->query->u.type_1);
 805                     if (error)
 806                     {
 807                         apdu_res = odr.create_searchResponse(
 808                             apdu_req, error,
 809                             addinfo_wr.len() ? addinfo_wr.c_str() : 0);
 810                     }
 811                     else
 812                     {
 813                         Z_APDU *apdu_1 = search(package, apdu_req, odr,
 814                                                 sparql_wr.c_str(), *it,
 815                                                 fset);
 816                         if (!apdu_res)
 817                             apdu_res = apdu_1;
 818                     }
 819                 }
 820             if (apdu_res == 0)
 821             {
 822                 apdu_res = odr.create_searchResponse(
 823                     apdu_req, YAZ_BIB1_DATABASE_DOES_NOT_EXIST, db.c_str());
 824             }
 825         }
 826     }
 827     else if (apdu_req->which == Z_APDU_presentRequest)
 828     {
 829         Z_PresentRequest *req = apdu_req->u.presentRequest;
 830         FrontendSets::iterator fset_it =
 831             m_frontend_sets.find(req->resultSetId);
 832         if (fset_it == m_frontend_sets.end())
 833         {
 834             apdu_res =
 835                 odr.create_presentResponse(
 836                     apdu_req, YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 837                     req->resultSetId);
 838             package.response() = apdu_res;
 839             return;
 840         }
 841         int number_returned = 0;
 842         int next_position = 0;
 843         int error_code = 0;
 844         std::string addinfo;
 845         Z_ElementSetNames *esn = 0;
 846         if (req->recordComposition)
 847         {
 848             if (req->recordComposition->which == Z_RecordComp_simple)
 849                 esn = req->recordComposition->u.simple;
 850             else
 851             {
 852                 apdu_res =
 853                     odr.create_presentResponse(
 854                         apdu_req,
 855                         YAZ_BIB1_ONLY_A_SINGLE_ELEMENT_SET_NAME_SUPPORTED,
 856                         0);
 857                 package.response() = apdu_res;
 858                 return;
 859             }
 860         }
 861         Z_Records *records = fetch(
 862             package,
 863             fset_it->second,
 864             odr, req->preferredRecordSyntax, esn,
 865             *req->resultSetStartPoint, *req->numberOfRecordsRequested,
 866             error_code, addinfo,
 867             &number_returned,
 868             &next_position);
 869         if (error_code)
 870         {
 871             apdu_res =
 872                 odr.create_presentResponse(apdu_req, error_code,
 873                                            addinfo.c_str());
 874         }
 875         else
 876         {
 877             apdu_res =
 878                 odr.create_presentResponse(apdu_req, 0, 0);
 879             Z_PresentResponse *resp = apdu_res->u.presentResponse;
 880             resp->records = records;
 881             *resp->numberOfRecordsReturned = number_returned;
 882             *resp->nextResultSetPosition = next_position;
 883         }
 884     }
 885     else
 886     {
 887         apdu_res = odr.create_close(apdu_req,
 888                                     Z_Close_protocolError,
 889                                     "sparql: unhandled APDU");
 890         package.session().close();
 891     }
 892
 893     assert(apdu_res);
 894     package.response() = apdu_res;
 895 }
 896
 897 void yf::SPARQL::process(mp::Package &package) const
 898 {
 899     Z_APDU *apdu;
 900     SessionPtr p = get_session(package, &apdu);
 901     if (p && apdu)
 902     {
 903         p->handle_z(package, apdu);
 904     }
 905     else
 906         package.move();
 907     release_session(package);
 908 }
 909
 910 static mp::filter::Base* filter_creator()
 911 {
 912     return new mp::filter::SPARQL;
 913 }
 914
 915 extern "C" {
 916     struct metaproxy_1_filter_struct metaproxy_1_filter_sparql = {
 917         0,
 918         "sparql",
 919         filter_creator
 920     };
 921 }
 922
 923
 924 /*
 925  * Local variables:
 926  * c-basic-offset: 4
 927  * c-file-style: "Stroustrup"
 928  * indent-tabs-mode: nil
 929  * End:
 930  * vim: shiftwidth=4 tabstop=8 expandtab
 931  */
 932