Ticket #710: 710-remote_server_public_api.diff

xapian-core/api/omenquire.cc

@@ -43 +43 @@
 #include "api/omenquireinternal.h"
 #include "str.h"
 #include "weight/weightinternal.h"
+#include "net/serialise.h"
 
 #include <algorithm>
 #include "autoptr.h"
@@ -133 +134 @@
     return description;
 }
 
+std::string
+RSet::serialise() const
+{
+    LOGCALL(API, std::string, "RSet::serialise", NO_ARGS);
+    RETURN(serialise_rset(*this));
+}
+
+RSet
+RSet::unserialise(const std::string &s)
+{
+    LOGCALL_STATIC(API, RSet, "RSet::unserialise", s);
+    RETURN(unserialise_rset(s));
+}
+
 namespace Internal {
 
 // Methods for Xapian::MSetItem
@@ -321 +336 @@
     return "Xapian::MSet(" + internal->get_description() + ")";
 }
 
+std::string
+MSet::serialise() const
+{
+    LOGCALL(API, std::string, "MSet::serialise", NO_ARGS);
+    RETURN(serialise_mset(*this));
+}
+
+MSet
+MSet::unserialise(const std::string &s)
+{
+    LOGCALL_STATIC(API, MSet, "MSet::unserialise", s);
+    RETURN(unserialise_mset(s.data(), s.data() + s.size()));
+}
+
 int
 MSet::Internal::convert_to_percent_internal(double wt) const
 {
@@ -620 +649 @@
     return query;
 }
 
+void
+Enquire::Internal::unserialise_stats(const string& serialised)
+{
+    stats.reset(new Xapian::Weight::Internal);
+    ::unserialise_stats(serialised, *(stats.get()));
+    stats->set_bounds_from_db(db);
+}
+
+const string
+Enquire::Internal::serialise_stats() const
+{
+    return ::serialise_stats(*(stats.get()));
+}
+
+void
+Enquire::Internal::prepare_mset(const RSet *rset,
+                                const MatchDecider *mdecider) const
+{
+    LOGCALL(MATCH, MSet, "Enquire::Internal::prepare_mset", rset | mdecider);
+
+    if (percent_cutoff && (sort_by == VAL || sort_by == VAL_REL)) {
+        throw Xapian::UnimplementedError("Use of a percentage cutoff while sorting primary by value isn't currently supported");
+    }
+
+    stats.reset(new Xapian::Weight::Internal);
+    match.reset(new ::MultiMatch(db, query, qlen, rset,
+                                 collapse_max, collapse_key,
+                                 percent_cutoff, weight_cutoff,
+                                 order, sort_key, sort_by, sort_value_forward,
+                                 time_limit, *(stats.get()), weight, spies,
+                                 (sorter.get() != NULL),
+                                 (mdecider != NULL)));
+}
+
 MSet
 Enquire::Internal::get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                             Xapian::doccount check_at_least, const RSet *rset,
@@ -644 +707 @@
         check_at_least = max(check_at_least, maxitems);
     }
 
-    AutoPtr<Xapian::Weight::Internal> stats(new Xapian::Weight::Internal);
-    ::MultiMatch match(db, query, qlen, rset,
-                       collapse_max, collapse_key,
-                       percent_cutoff, weight_cutoff,
-                       order, sort_key, sort_by, sort_value_forward,
-                       time_limit, *(stats.get()), weight, spies,
-                       (sorter.get() != NULL),
-                       (mdecider != NULL));
-    // Run query and put results into supplied Xapian::MSet object.
-    MSet retval;
-    match.get_mset(first, maxitems, check_at_least, retval,
-                   *(stats.get()), mdecider, sorter.get());
-    if (first_orig != first && retval.internal.get()) {
-        retval.internal->firstitem = first_orig;
-    }
+    try {
+        if (!stats || !match) {
+            prepare_mset(rset, mdecider);
+        }
 
-    Assert(weight->name() != "bool" || retval.get_max_possible() == 0);
+        // Run query and put results into supplied Xapian::MSet object.
+        MSet retval;
+        match->get_mset(first, maxitems, check_at_least, retval,
+                    *(stats.get()), mdecider, sorter.get());
+        if (first_orig != first && retval.internal.get()) {
+            retval.internal->firstitem = first_orig;
+        }
 
-    // The Xapian::MSet needs to have a pointer to ourselves, so that it can
-    // retrieve the documents.  This is set here explicitly to avoid having
-    // to pass it into the matcher, which gets messy particularly in the
-    // networked case.
-    retval.internal->enquire = this;
+        Assert(weight->name() != "bool" || retval.get_max_possible() == 0);
 
-    if (!retval.internal->stats) {
-        retval.internal->stats = stats.release();
-    }
+        // The Xapian::MSet needs to have a pointer to ourselves, so that it can
+        // retrieve the documents.  This is set here explicitly to avoid having
+        // to pass it into the matcher, which gets messy particularly in the
+        // networked case.
+        retval.internal->enquire = this;
+
+        if (!retval.internal->stats) {
+            retval.internal->stats = stats.release();
+        } else {
+            stats.reset();
+        }
+
+        match.reset();
 
-    RETURN(retval);
+        RETURN(retval);
+    } catch(...) {
+        stats.reset();
+        match.reset();
+        throw;
+    }
 }
 
 ESet
@@ -1006 +1075 @@
     internal->time_limit = time_limit;
 }
 
+void
+Enquire::unserialise_stats(const string& serialised)
+{
+    internal->unserialise_stats(serialised);
+}
+
+const string
+Enquire::serialise_stats() const
+{
+    RETURN(internal->serialise_stats());
+}
+
+void
+Enquire::prepare_mset(const RSet *rset,
+                      const MatchDecider *mdecider) const
+{
+    LOGCALL(API, Xapian::MSet, "Xapian::Enquire::prepare_mset", maxitems | rset | mdecider);
+
+    internal->prepare_mset(rset, mdecider);
+}
+
 MSet
 Enquire::get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                   Xapian::doccount check_at_least, const RSet *rset,

xapian-core/api/omenquireinternal.h

@@ -37 +37 @@
 #include <map>
 #include <set>
 
+#include "autoptr.h"
 #include "weight/weightinternal.h"
 
 using namespace std;
@@ -151 +152 @@
 
         Xapian::Internal::opt_intrusive_ptr<KeyMaker> sorter;
 
+        mutable AutoPtr<Xapian::Weight::Internal> stats;
+        mutable AutoPtr<::MultiMatch> match;
+
         double time_limit;
 
         /** The weight to use for this query.
@@ -183 +187 @@
 
         void set_query(const Query & query_, termcount qlen_);
         const Query & get_query() const;
+
+        void unserialise_stats(const string& serialised);
+        const string serialise_stats() const;
+
+        void prepare_mset(const RSet *omrset,
+                          const MatchDecider *mdecider) const;
+
         MSet get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                       Xapian::doccount check_at_least,
                       const RSet *omrset,

xapian-core/include/xapian/enquire.h

@@ -262 +262 @@
 
         /// Return a string describing this object.
         std::string get_description() const;
+
+        /** Serialise RSet into a string.
+         *
+         *  The document representation may change between Xapian releases:
+         *  even between minor versions.  However, it is guaranteed not to
+         *  change if the remote database protocol has not changed between
+         *  releases.
+         */
+        std::string serialise() const;
+
+        /** Unserialise a document from a string produced by serialise().
+         */
+        static RSet unserialise(const std::string &serialised);
+
 };
 
 /** Base class for matcher decision functor.
@@ -619 +633 @@
          */
         void set_time_limit(double time_limit);
 
+        void unserialise_stats(const std::string& serialised);
+        const std::string serialise_stats() const;
+
         /** Get (a portion of) the match set for the current query.
          *
          *  @param first     the first item in the result set to return.
@@ -657 +674 @@
          *
          *  @{
          */
+        void prepare_mset(const RSet * omrset = 0,
+                          const MatchDecider * mdecider = 0) const;
         MSet get_mset(Xapian::doccount first, Xapian::doccount maxitems,
                       Xapian::doccount checkatleast = 0,
                       const RSet * omrset = 0,

xapian-core/include/xapian/mset.h

@@ -179 +179 @@
     /// Return a string describing this object.
     std::string get_description() const;
 
+    /** Serialise MSet into a string.
+     *
+     *  The document representation may change between Xapian releases:
+     *  even between minor versions.  However, it is guaranteed not to
+     *  change if the remote database protocol has not changed between
+     *  releases.
+     */
+    std::string serialise() const;
+
+    /** Unserialise a document from a string produced by serialise().
+     */
+    static MSet unserialise(const std::string &serialised);
+
     /** @private @internal MSet is what the C++ STL calls a container.
      *
      *  The following typedefs allow the class to be used in templates in the

xapian-core/net/remoteserver.cc

@@ -36 +36 @@
 
 #include "autoptr.h"
 #include "length.h"
-#include "matcher/multimatch.h"
+#include "api/omenquireinternal.h"
 #include "noreturn.h"
 #include "omassert.h"
 #include "realtime.h"
@@ -393 +393 @@
 void
 RemoteServer::msg_query(const string &message_in)
 {
+    if (!db)
+        throw_no_db();
+
     const char *p = message_in.c_str();
     const char *p_end = p + message_in.size();
 
+    Xapian::Enquire enquire(*db);
+
     // Unserialise the Query.
     size_t len;
     decode_length_and_check(&p, p_end, len);
@@ -406 +411 @@
     Xapian::termcount qlen;
     decode_length(&p, p_end, qlen);
 
+    enquire.set_query(query, qlen);
+
     Xapian::valueno collapse_max;
     decode_length(&p, p_end, collapse_max);
 
@@ -413 +420 @@
     if (collapse_max)
         decode_length(&p, p_end, collapse_key);
 
+    enquire.set_collapse_key(collapse_key, collapse_max);
+
     if (p_end - p < 4 || *p < '0' || *p > '2') {
         throw Xapian::NetworkError("bad message (docid_order)");
     }
     Xapian::Enquire::docid_order order;
     order = static_cast<Xapian::Enquire::docid_order>(*p++ - '0');
 
+    enquire.set_docid_order(order);
+
     Xapian::valueno sort_key;
     decode_length(&p, p_end, sort_key);
 
@@ -433 +444 @@
     }
     bool sort_value_forward(*p++ != '0');
 
+    switch(sort_by) {
+        case Xapian::Enquire::Internal::REL:
+            enquire.set_sort_by_relevance();
+            break;
+        case Xapian::Enquire::Internal::VAL:
+            enquire.set_sort_by_value(sort_key, sort_value_forward);
+            break;
+        case Xapian::Enquire::Internal::VAL_REL:
+            enquire.set_sort_by_value_then_relevance(sort_key, sort_value_forward);
+            break;
+        case Xapian::Enquire::Internal::REL_VAL:
+            enquire.set_sort_by_relevance_then_value(sort_key, sort_value_forward);
+            break;
+    }
+
     double time_limit = unserialise_double(&p, p_end);
 
+    enquire.set_time_limit(time_limit);
+
     int percent_cutoff = *p++;
     if (percent_cutoff < 0 || percent_cutoff > 100) {
         throw Xapian::NetworkError("bad message (percent_cutoff)");
@@ -445 +473 @@
         throw Xapian::NetworkError("bad message (weight_cutoff)");
     }
 
+    enquire.set_cutoff(percent_cutoff, weight_cutoff);
+
     // Unserialise the Weight object.
     decode_length_and_check(&p, p_end, len);
     string wtname(p, len);
@@ -461 +491 @@
 
     decode_length_and_check(&p, p_end, len);
     AutoPtr<Xapian::Weight> wt(wttype->unserialise(string(p, len)));
+    enquire.set_weighting_scheme(*wt);
     p += len;
 
     // Unserialise the RSet object.
@@ -469 +500 @@
     p += len;
 
     // Unserialise any MatchSpy objects.
-    vector<Xapian::Internal::opt_intrusive_ptr<Xapian::MatchSpy>> matchspies;
+    vector<Xapian::MatchSpy*> matchspies;
     while (p != p_end) {
         decode_length_and_check(&p, p_end, len);
         string spytype(p, len);
@@ -481 +512 @@
         p += len;
 
         decode_length_and_check(&p, p_end, len);
-        matchspies.push_back(spyclass->unserialise(string(p, len), reg)->release());
+        Xapian::MatchSpy *spy = spyclass->unserialise(string(p, len), reg);
+        matchspies.push_back(spy);
+        enquire.add_matchspy(spy->release());
         p += len;
     }
 
-    Xapian::Weight::Internal local_stats;
-    MultiMatch match(*db, query, qlen, &rset, collapse_max, collapse_key,
-                     percent_cutoff, weight_cutoff, order,
-                     sort_key, sort_by, sort_value_forward, time_limit,
-                     local_stats, wt.get(), matchspies, false, false);
+    enquire.prepare_mset(&rset, nullptr);
 
-    send_message(REPLY_STATS, serialise_stats(local_stats));
+    send_message(REPLY_STATS, enquire.serialise_stats());
 
     string message;
     get_message(active_timeout, message, MSG_GETMSET);
@@ -506 +535 @@
     Xapian::termcount check_at_least;
     decode_length(&p, p_end, check_at_least);
 
-    message.erase(0, message.size() - (p_end - p));
-    AutoPtr<Xapian::Weight::Internal> total_stats(new Xapian::Weight::Internal);
-    unserialise_stats(message, *(total_stats.get()));
-    total_stats->set_bounds_from_db(*db);
+    enquire.unserialise_stats(std::string(p, p_end));
 
-    Xapian::MSet mset;
-    match.get_mset(first, maxitems, check_at_least, mset, *(total_stats.get()), 0, 0);
-    mset.internal->stats = total_stats.release();
+    Xapian::MSet mset = enquire.get_mset(first, maxitems, check_at_least);
 
     message.resize(0);
     for (auto i : matchspies) {
@@ -521 +545 @@
         message += encode_length(spy_results.size());
         message += spy_results;
     }
-    message += serialise_mset(mset);
+    message += mset.serialise();
     send_message(REPLY_RESULTS, message);
 }