Ticket #50: opsynonym4.patch

matcher/Makefile.mk

@@ -17 +17 @@
         matcher/remotesubmatch.h\
         matcher/scaleweight.h\
         matcher/selectpostlist.h\
+        matcher/synonympostlist.h\
         matcher/valuerangepostlist.h\
         matcher/xorpostlist.h
 
@@ -53 +54 @@
         matcher/scaleweight.cc\
         matcher/selectpostlist.cc\
         matcher/stats.cc\
+        matcher/synonympostlist.cc\
         matcher/tradweight.cc\
         matcher/valuerangepostlist.cc\
         matcher/weight.cc\

matcher/multimatch.cc

@@ -374 +374 @@
     }
     Assert(!postlists.empty());
 
+#ifdef XAPIAN_DEBUG_VERBOSE
+    {
+        DEBUGLINE(MATCH, "termfreqandwts:");
+        map<string, Xapian::MSet::Internal::TermFreqAndWeight>::const_iterator tfwi;
+        for (tfwi = termfreqandwts.begin(); tfwi != termfreqandwts.end(); ++tfwi)
+        {
+            DEBUGLINE(MATCH, "termfreqandwt[" << tfwi->first << "] = " << tfwi->second.termfreq << ", " << tfwi->second.termweight);
+        }
+    }
+#endif
+
     // Get a single combined postlist
     PostList *pl;
     if (postlists.size() == 1) {
@@ -794 +805 @@
                 DEBUGLINE(MATCH, "denom = " << denom << " percent_scale = " << percent_scale);
                 Assert(percent_scale <= denom);
                 denom *= greatest_wt;
+                if (denom == 0) {
+                    percent_scale = 1.0 / greatest_wt;
+                } else {
                 Assert(denom > 0);
                 percent_scale /= denom;
+                }
             } else {
                 // If all the terms match, the 2 sums of weights cancel
                 percent_scale = 1.0 / greatest_wt;

matcher/localmatch.cc

@@ -32 +32 @@
 #include "omqueryinternal.h"
 #include "queryoptimiser.h"
 #include "scaleweight.h"
+#include "stats.h"
+#include "synonympostlist.h"
 #include "weightinternal.h"
-#include "stats.h"
 
 #include <cfloat>
 #include <cmath>
@@ -114 +115 @@
 }
 
 PostList *
+LocalSubMatch::make_synonym_postlist(PostList * or_pl, MultiMatch * matcher)
+{
+    DEBUGCALL(MATCH, PostList *, "LocalSubMatch::make_synonym_postlist",
+              "[or_pl]");
+    DEBUGLINE(MATCH, "or_pl->get_termfreq() = " << or_pl->get_termfreq_est());
+    AutoPtr<SynonymPostList> res(new SynonymPostList(or_pl, matcher));
+    AutoPtr<Xapian::Weight> wt;
+
+    // FIXME:1.1: create the Xapian::Weight::Internal directly, and hold it in
+    // an AutoPtr until supplying it to wt_factory->create() in case of an
+    // exception.
+    Xapian::Weight::Internal * wt_internal(stats->create_weight_internal());
+    wt_internal->termfreq = or_pl->get_termfreq_est();
+    wt_internal->reltermfreq = 0; // FIXME - calculate this.
+    wt = wt_factory->create(wt_internal, qlen, 1, "");
+
+    res->set_weight(wt.release());
+    RETURN(res.release());
+}
+
+PostList *
 LocalSubMatch::postlist_from_op_leaf_query(const Xapian::Query::Internal *query,
                                            double factor)
 {
     DEBUGCALL(MATCH, PostList *, "LocalSubMatch::postlist_from_op_leaf_query",
-              query << ", " << factor);
+              query->get_description() << ", " << factor);
     Assert(query);
     AssertEq(query->op, Xapian::Query::Internal::OP_LEAF);
     Assert(query->subqs.empty());
@@ -142 +164 @@
         Xapian::doccount tf = stats->get_termfreq(query->tname);
         Xapian::weight weight = boolean ? 0 : wt->get_maxpart();
         Xapian::MSet::Internal::TermFreqAndWeight info(tf, weight);
+        DEBUGLINE(MATCH, "Setting term_info[" << query->tname << "] to (" << tf << ", " << weight << ")");
         term_info.insert(make_pair(query->tname, info));
     } else if (!boolean) {
         i->second.termweight += wt->get_maxpart();
+        AssertEq(stats->get_termfreq(query->tname), i->second.termfreq);
+        DEBUGLINE(MATCH, "Increasing term_info[" << query->tname << "] to (" << i->second.termfreq << ", " << i->second.termweight << ")");
     }
 
     LeafPostList * pl = db->open_post_list(query->tname);

matcher/localmatch.h

@@ -86 +86 @@
     PostList * get_postlist_and_term_info(MultiMatch *matcher,
         std::map<string, Xapian::MSet::Internal::TermFreqAndWeight> *termfreqandwts);
 
+    /** Convert a postlist into a synonym postlist.
+     */
+    PostList * make_synonym_postlist(PostList * or_pl, MultiMatch * matcher);
+
     /** Convert an OP_LEAF query to a PostList.
      *
      *  This is called by QueryOptimiser when it reaches an OP_LEAF query.

matcher/synonympostlist.h

@@ +1 @@
+/* synonympostlist.h: Combine subqueries, weighting as if they are synonyms
+ *
+ * Copyright 2007 Lemur Consulting Ltd
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+#ifndef XAPIAN_INCLUDED_SYNONYMPOSTLIST_H
+#define XAPIAN_INCLUDED_SYNONYMPOSTLIST_H
+
+#include "multimatch.h"
+#include "postlist.h"
+#include "stats.h"
+#include <vector>
+
+/** A postlist comprising several postlists SYNONYMed together.
+ *
+ *  This postlist returns all postings in the OR of the sub postlists, but
+ *  returns weights as if they represented a single term.  The term frequency
+ *  portion of the weight is approximated.
+ */
+class SynonymPostList : public PostList {
+    private:
+        /** The subtree, which starts as an OR of all the sub-postlists being
+         *  joined with Synonym, but may decay into something else.
+         */
+        PostList * subtree;
+
+        /** The object which is using this postlist to perform
+         *  a match.  This object needs to be notified when the
+         *  tree changes such that the maximum weights need to be
+         *  recalculated.
+         */
+        MultiMatch *matcher;
+
+        /** Weighting object used for calculating the synonym weights.
+         */
+        const Xapian::Weight * wt;
+
+        /** Flag indicating whether the weighting object needs the doclength.
+         */
+        bool want_doclength;
+
+    public:
+        SynonymPostList(PostList *subtree_, MultiMatch * matcher_);
+        ~SynonymPostList();
+
+        /** Set the weight object to be used for the synonym postlist.
+         *
+         *  Ownership of the weight object passes to the synonym postlist - the
+         *  caller must not delete it after use.
+         */
+        void set_weight(const Xapian::Weight * wt_);
+
+        PostList *next(Xapian::weight w_min);
+        PostList *skip_to(Xapian::docid did, Xapian::weight w_min);
+
+        Xapian::weight get_weight() const;
+        Xapian::weight get_maxweight() const;
+        Xapian::weight recalc_maxweight();
+
+        // The following methods just call through to the subtree.
+        Xapian::termcount get_wdf() const;
+        Xapian::doccount get_termfreq_min() const;
+        Xapian::doccount get_termfreq_est() const;
+        Xapian::doccount get_termfreq_max() const;
+        Xapian::docid get_docid() const;
+        Xapian::doclength get_doclength() const;
+        PositionList * read_position_list();
+        PositionList * open_position_list() const;
+        bool at_end() const;
+
+        std::string get_description() const;
+};
+
+#endif /* XAPIAN_INCLUDED_SYNONYMPOSTLIST_H */

matcher/queryoptimiser.cc

@@ -51 +51 @@
 QueryOptimiser::do_subquery(const Xapian::Query::Internal * query, double factor)
 {
     DEBUGCALL(MATCH, PostList *, "QueryOptimiser::do_subquery",
-              query << ", " << factor);
+              query->get_description() << ", " << factor);
 
     // Handle QueryMatchNothing.
     if (!query) RETURN(new EmptyPostList());
@@ -99 +99 @@
             RETURN(do_subquery(query->subqs[0], sub_factor));
         }
 
+        case Xapian::Query::OP_SYNONYM: {
+            RETURN(do_synonym(query, factor));
+        }
+
         default:
             Assert(false);
             RETURN(NULL);
     }
 }
 
+PostList *
+QueryOptimiser::do_leaf(const Xapian::Query::Internal * query, double factor) {
+    return localsubmatch.postlist_from_op_leaf_query(query, factor);
+}
+
 struct PosFilter {
     PosFilter(Xapian::Query::Internal::op_t op_, size_t begin_, size_t end_,
               Xapian::termcount window_)
@@ -122 +131 @@
 QueryOptimiser::do_and_like(const Xapian::Query::Internal *query, double factor)
 {
     DEBUGCALL(MATCH, PostList *, "QueryOptimiser::do_and_like",
-              query << ", " << factor);
+              query->get_description() << ", " << factor);
 
     list<PosFilter> pos_filters;
     vector<PostList *> plists;
@@ -172 +181 @@
                             list<PosFilter> & pos_filters)
 {
     DEBUGCALL(MATCH, void, "QueryOptimiser::do_and_like",
-              query << ", " << factor << ", [and_plists], [pos_filters]");
+              query->get_description() << ", " <<
+              factor << ", [and_plists], [pos_filters],");
 
     Xapian::Query::Internal::op_t op = query->op;
     Assert(is_and_like(op));
@@ -251 +261 @@
 QueryOptimiser::do_or_like(const Xapian::Query::Internal *query, double factor)
 {
     DEBUGCALL(MATCH, PostList *, "QueryOptimiser::do_or_like",
-              query << ", " << factor);
+              query->get_description() << ", " << factor);
 
     // FIXME: we could optimise by merging OP_ELITE_SET and OP_OR like we do
     // for AND-like operations.
     Xapian::Query::Internal::op_t op = query->op;
     Assert(op == Xapian::Query::OP_ELITE_SET || op == Xapian::Query::OP_OR ||
-           op == Xapian::Query::OP_XOR);
+           op == Xapian::Query::OP_XOR || op == Xapian::Query::OP_SYNONYM);
 
+    // We build an OR tree for OP_SYNONYM.  (The resulting tree will then be
+    // passed into a SynonymPostList, from which the weightings will come.)
+    if (op == Xapian::Query::OP_SYNONYM) {
+        op = Xapian::Query::OP_OR;
+    }
+
     const Xapian::Query::Internal::subquery_list &queries = query->subqs;
     AssertRel(queries.size(), >=, 2);
 
@@ -333 +349 @@
                   ComparePostListTermFreqAscending());
     }
 }
+
+PostList *
+QueryOptimiser::do_synonym(const Xapian::Query::Internal *query, double factor)
+{
+    DEBUGCALL(MATCH, PostList *, "QueryOptimiser::do_synonym",
+              query->get_description() << ", " << factor);
+
+    if (factor == 0.0) {
+        // If we have a factor of 0, we don't care about the weights, so
+        // we're just like a normal OR query.
+        RETURN(do_or_like(query, 0.0));
+    }
+
+    AssertEq(query->wqf, 0); // FIXME - should we be doing something with the wqf?
+
+    // Build a postlist tree which we'll use to get the frequencies.
+    AutoPtr<PostList> freq_pl(do_or_like(query, 0.0));
+
+    RETURN(localsubmatch.make_synonym_postlist(do_or_like(query, 0.0),
+                                               matcher));
+}

matcher/queryoptimiser.h

@@ -63 +63 @@
      *
      *  @return         A PostList.
      */
-    PostList * do_leaf(const Xapian::Query::Internal * query, double factor) {
-        return localsubmatch.postlist_from_op_leaf_query(query, factor);
-    }
+    PostList * do_leaf(const Xapian::Query::Internal * query, double factor);
 
     /** Optimise an AND-like Xapian::Query::Internal subtree into a PostList
      *  subtree.
@@ -101 +99 @@
      */
     PostList * do_or_like(const Xapian::Query::Internal *query, double factor);
 
+    /** Optimise a synonym Xapian::Query::Internal subtree into a PostList
+     *
+     *  @param query    The subtree to optimise.
+     *  @param factor   How much to scale weights for this subtree by.
+     *
+     *  @return         A PostList subtree.
+     */
+    PostList * do_synonym(const Xapian::Query::Internal *query, double factor);
+
   public:
     QueryOptimiser(const Xapian::Database::Internal & db_,
                    LocalSubMatch & localsubmatch_,

matcher/synonympostlist.cc

@@ +1 @@
+/* synonympostlist.cc: Combine subqueries, weighting as if they are synonyms
+ *
+ * Copyright 2007 Lemur Consulting Ltd
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+ * USA
+ */
+
+#include <config.h>
+
+#include "synonympostlist.h"
+#include "branchpostlist.h"
+#include "omassert.h"
+#include "omdebug.h"
+
+SynonymPostList::SynonymPostList(PostList *subtree_,
+                                 MultiMatch * matcher_)
+        : subtree(subtree_),
+          matcher(matcher_),
+          wt(NULL),
+          want_doclength(false)
+{
+}
+
+SynonymPostList::~SynonymPostList()
+{
+    delete wt;
+    delete subtree;
+}
+
+void
+SynonymPostList::set_weight(const Xapian::Weight * wt_)
+{
+    delete(wt);
+    wt = wt_;
+    want_doclength = wt_->get_sumpart_needs_doclength();
+}
+
+PostList *
+SynonymPostList::next(Xapian::weight w_min)
+{
+    DEBUGCALL(MATCH, PostList *, "SynonymPostList::next", w_min);
+    next_handling_prune(subtree, w_min, matcher);
+    RETURN(NULL);
+}
+
+PostList *
+SynonymPostList::skip_to(Xapian::docid did, Xapian::weight w_min)
+{
+    DEBUGCALL(MATCH, PostList *, "SynonymPostList::skip_to", did << ", " << w_min);
+    skip_to_handling_prune(subtree, did, w_min, matcher);
+    RETURN(NULL);
+}
+
+Xapian::weight
+SynonymPostList::get_weight() const
+{
+    return wt->get_sumpart(get_wdf(), want_doclength ? get_doclength() : 0);
+}
+
+Xapian::weight
+SynonymPostList::get_maxweight() const
+{
+    return wt->get_maxpart();
+}
+
+Xapian::weight
+SynonymPostList::recalc_maxweight()
+{
+    return SynonymPostList::get_maxweight();
+}
+
+Xapian::termcount
+SynonymPostList::get_wdf() const {
+    return subtree->get_wdf();
+}
+
+Xapian::doccount 
+SynonymPostList::get_termfreq_min() const {
+    return subtree->get_termfreq_min();
+}
+
+Xapian::doccount 
+SynonymPostList::get_termfreq_est() const {
+    return subtree->get_termfreq_est();
+}
+
+Xapian::doccount 
+SynonymPostList::get_termfreq_max() const {
+    return subtree->get_termfreq_max();
+}
+
+Xapian::docid 
+SynonymPostList::get_docid() const {
+    return subtree->get_docid();
+}
+
+Xapian::doclength 
+SynonymPostList::get_doclength() const {
+    return subtree->get_doclength();
+}
+
+PositionList * 
+SynonymPostList::read_position_list() {
+    return subtree->read_position_list();
+}
+
+PositionList * 
+SynonymPostList::open_position_list() const {
+    return subtree->open_position_list();
+}
+
+bool 
+SynonymPostList::at_end() const {
+    return subtree->at_end();
+}
+
+std::string
+SynonymPostList::get_description() const
+{
+    return "(Synonym " + subtree->get_description() + ")";
+}

tests/api_db.cc

@@ -1171 +1171 @@
     return true;
 }
 
+// Check a synonym search
+DEFINE_TESTCASE(synonym1, backend) {
+    Xapian::Database db(get_database("etext"));
+    Xapian::doccount lots = 214;
+    vector<vector<Xapian::Query> > subqueries_list;
+
+    vector<Xapian::Query> subqueries;
+    subqueries.push_back(Xapian::Query("date"));
+    subqueries_list.push_back(subqueries);
+
+    subqueries.clear();
+    subqueries.push_back(Xapian::Query("sky"));
+    subqueries.push_back(Xapian::Query("date"));
+    subqueries_list.push_back(subqueries);
+
+    subqueries.clear();
+    subqueries.push_back(Xapian::Query("date"));
+    subqueries.push_back(Xapian::Query(Xapian::Query::OP_OR,
+                                       Xapian::Query("sky"),
+                                       Xapian::Query("glove")));
+    subqueries_list.push_back(subqueries);
+
+    subqueries.clear();
+    subqueries.push_back(Xapian::Query("sky"));
+    subqueries.push_back(Xapian::Query("date"));
+    subqueries.push_back(Xapian::Query("stein"));
+    subqueries.push_back(Xapian::Query("ally"));
+    subqueries_list.push_back(subqueries);
+
+    subqueries.clear();
+    subqueries.push_back(Xapian::Query("sky"));
+    subqueries.push_back(Xapian::Query(Xapian::Query::OP_PHRASE,
+                                       Xapian::Query("date"),
+                                       Xapian::Query("stein")));
+    subqueries_list.push_back(subqueries);
+
+    for (vector<vector<Xapian::Query> >::const_iterator
+         qlist = subqueries_list.begin();
+         qlist != subqueries_list.end(); ++qlist)
+    {
+        // Run two queries, one joining the subqueries with OR and one joining them
+        // with SYNONYM.
+        Xapian::Enquire enquire(db);
+        enquire.set_query(Xapian::Query(Xapian::Query::OP_OR, qlist->begin(), qlist->end()));
+        Xapian::MSet ormset = enquire.get_mset(0, lots);
+        Xapian::Query synquery(Xapian::Query::OP_SYNONYM, qlist->begin(), qlist->end());
+        tout << synquery << "\n";
+        enquire.set_query(synquery);
+        Xapian::MSet mset = enquire.get_mset(0, lots);
+
+        // Check that the queries return some results.
+        TEST_NOT_EQUAL(mset.size(), 0);
+        // Check that the queries return the same number of results.
+        TEST_EQUAL(mset.size(), ormset.size());
+        map<Xapian::docid, Xapian::weight> values_or;
+        map<Xapian::docid, Xapian::weight> values_synonym;
+        for (Xapian::doccount i = 0; i < mset.size(); ++i) {
+            values_or[*ormset[i]] = ormset[i].get_weight();
+            values_synonym[*mset[i]] = mset[i].get_weight();
+        }
+        TEST_EQUAL(values_or.size(), values_synonym.size());
+
+        /* Check that the weights for each item in the or mset are different from
+         * those in the synonym mset. (Note, it's technically possible that some
+         * might be equal, but unlikely, so for now we just check that none are.
+         * If this causes problems, we can change to just checking that most
+         * differ.) */
+        for (map<Xapian::docid, Xapian::weight>::const_iterator
+             j = values_or.begin();
+             j != values_or.end(); ++j)
+        {
+            Xapian::docid did = j->first;
+            // Check that all the results in the or tree make it to the synonym tree.
+            TEST(values_synonym.find(did) != values_synonym.end());
+            if (qlist->size() == 1) {
+                // Check that the weights are the same.
+                TEST_EQUAL(values_or[did], values_synonym[did]);
+            } else {
+                // Check that the weights differ.
+                TEST_NOT_EQUAL(values_or[did], values_synonym[did]);
+            }
+        }
+    }
+    return true;
+}
+
 // tests that specifying a nonexistent input file throws an exception.
 DEFINE_TESTCASE(quartzdatabaseopeningerror1, quartz) {
     mkdir(".quartz", 0755);

include/xapian/query.h

@@ -111 +111 @@
             /** Select an elite set from the subqueries, and perform
              *  a query with these combined as an OR query.
              */
-            OP_ELITE_SET
+            OP_ELITE_SET,
+
+            /** Treat a set of queries as synonyms.
+             *
+             *  This returns all results which match at least one of the
+             *  queries, but weighting as if all the sub-queries are instances
+             *  of the same term: so multiple matching terms for a document
+             *  increase the wdf value used, and the term frequency is based on
+             *  the number of documents which would match an OR of all the
+             *  subqueries.
+             *
+             *  The term frequency used will usually be an approximation,
+             *  because calculating the precise combined term frequency would
+             *  be overly expensive.
+             *
+             *  Identical to OP_OR, except for the weightings returned.
+             */
+            OP_SYNONYM
         } op;
 
         /** Copy constructor. */

common/remoteprotocol.h

@@ -38 +38 @@
 // 30.3: New MSG_GETMSET which passes check_at_least parameter.
 // 30.4: New query operator OP_SCALE_WEIGHT.
 // 30.5: New MSG_GETMSET which expects MSet's percent_factor to be returned.
+// 30.6: Add synonym queries (add operator to the serialised form of queries)
 #define XAPIAN_REMOTE_PROTOCOL_MAJOR_VERSION 30
-#define XAPIAN_REMOTE_PROTOCOL_MINOR_VERSION 5
+#define XAPIAN_REMOTE_PROTOCOL_MINOR_VERSION 6
 
 /* When we move to version 31:
  * + Remove MSG_DELETEDOCUMENT_PRE_30_2

api/omqueryinternal.cc

@@ -59 +59 @@
         case Xapian::Query::OP_PHRASE:
         case Xapian::Query::OP_ELITE_SET:
         case Xapian::Query::OP_VALUE_RANGE:
+        case Xapian::Query::OP_SYNONYM:
             return 0;
         case Xapian::Query::OP_SCALE_WEIGHT:
             return 1;
@@ -91 +92 @@
         case Xapian::Query::OP_NEAR:
         case Xapian::Query::OP_PHRASE:
         case Xapian::Query::OP_ELITE_SET:
+        case Xapian::Query::OP_SYNONYM:
             return UINT_MAX;
         default:
             Assert(false);
@@ -187 +189 @@
                 result += ".";
                 result += str_parameter; // serialise_double(get_dbl_parameter());
                 break;
+            case Xapian::Query::OP_SYNONYM:
+                result += "=";
+                break;
         }
     }
     return result;
@@ -213 +218 @@
         case Xapian::Query::OP_ELITE_SET:       name = "ELITE_SET"; break;
         case Xapian::Query::OP_VALUE_RANGE:     name = "VALUE_RANGE"; break;
         case Xapian::Query::OP_SCALE_WEIGHT:    name = "SCALE_WEIGHT"; break;
+        case Xapian::Query::OP_SYNONYM:         name = "SYNONYM"; break;
     }
     return name;
 }
@@ -492 +498 @@
                     return qint_from_vector(Xapian::Query::OP_SCALE_WEIGHT,
                                             subqs, 0, param);
                 }
-                default:
+                case '=': {
+                    return qint_from_vector(Xapian::Query::OP_SYNONYM, subqs);
+                }
+                default:
                     DEBUGLINE(UNKNOWN, "Can't parse remainder `" << p - 1 << "'");
                     throw Xapian::InvalidArgumentError("Invalid query string");
             }
@@ -662 +671 @@
         case OP_ELITE_SET:
         case OP_OR:
         case OP_XOR:
+        case OP_SYNONYM:
             // Doing an "OR" type operation - if we've got any MatchNothing
             // subnodes, drop them; except that we mustn't become an empty
             // node due to this, so we never drop a MatchNothing subnode
@@ -746 +756 @@
                 }
             }
             break;
-        case OP_OR: case OP_AND: case OP_XOR:
+        case OP_OR: case OP_AND: case OP_XOR: case OP_SYNONYM:
             // Remove duplicates if we can.
             if (subqs.size() > 1) collapse_subqs();
             break;
@@ -790 +800 @@
 void
 Xapian::Query::Internal::collapse_subqs()
 {
-    Assert(op == OP_OR || op == OP_AND || op == OP_XOR);
+    Assert(op == OP_OR || op == OP_AND || op == OP_XOR || op == OP_SYNONYM);
     typedef set<Xapian::Query::Internal *, SortPosName> subqtable;
     subqtable sqtab;
 
@@ -865 +875 @@
     Assert(!is_leaf(op));
     if (subq == 0) {
         subqs.push_back(0);
-    } else if (op == subq->op && (op == OP_AND || op == OP_OR || op == OP_XOR)) {
+    } else if (op == subq->op && (op == OP_AND || op == OP_OR || op == OP_XOR || op == OP_SYNONYM)) {
         // Distribute the subquery.
         for (subquery_list::const_iterator i = subq->subqs.begin();
              i != subq->subqs.end(); i++) {