Ticket #50: opsynonym_changes_12353_12354.patch

xapian-maintainer-tools/win32msvc/win32_matcher.mak

@@ -35 +35 @@
     $(INTDIR)\rset.obj\
     $(INTDIR)\scaleweight.obj\
     $(INTDIR)\selectpostlist.obj\
+    $(INTDIR)\synonympostlist.obj\
     $(INTDIR)\stats.obj\
     $(INTDIR)\tradweight.obj\
     $(INTDIR)\valuerangepostlist.obj\
@@ -65 +66 @@
     $(INTDIR)\rset.cc\
     $(INTDIR)\scaleweight.cc\
     $(INTDIR)\selectpostlist.cc\
+    $(INTDIR)\synonympostlist.cc\
     $(INTDIR)\stats.cc\
     $(INTDIR)\tradweight.cc\
     $(INTDIR)\valuerangepostlist.cc\

xapian-core/queryparser/queryparser.lemony

@@ -279 +279 @@
             end = db.synonyms_end(term);
         }
         while (syn != end) {
-            q = Query(Query::OP_OR, q, Query(*syn, 1, pos));
+            q = Query(Query::OP_SYNONYM, q, Query(*syn, 1, pos));
             ++syn;
         }
     }
@@ -345 +345 @@
         }
     }
     delete this;
-    return new Query(Query::OP_OR, subqs.begin(), subqs.end());
+    return new Query(Query::OP_SYNONYM, subqs.begin(), subqs.end());
 }
 
 Query *
@@ -357 +357 @@
     for (piter = prefixes.begin(); piter != prefixes.end(); ++piter) {
         string root = *piter;
         root += name;
+        vector<Query> subqs2;
         TermIterator t = db.allterms_begin(root);
         while (t != db.allterms_end(root)) {
-            subqs.push_back(Query(*t, 1, pos));
+            subqs2.push_back(Query(*t, 1, pos));
             ++t;
         }
+        subqs.push_back(Query(Query::OP_SYNONYM, subqs2.begin(), subqs2.end()));
         // Add the term, as it would normally be handled, as an alternative.
         subqs.push_back(Query(make_term(*piter), 1, pos));
     }
@@ -1168 +1170 @@
                 subqs2.push_back(Query(*syn, 1, pos));
                 ++syn;
             }
-            Query q_synonym_terms(Query::OP_OR, subqs2.begin(), subqs2.end());
+            Query q_synonym_terms(Query::OP_SYNONYM, subqs2.begin(), subqs2.end());
             subqs2.clear();
-            subqs.push_back(Query(Query::OP_OR,
+            subqs.push_back(Query(Query::OP_SYNONYM,
                                   q_original_terms, q_synonym_terms));
         }
     } else {

xapian-core/matcher/Makefile.mk

@@ -18 +18 @@
         matcher/queryoptimiser.h\
         matcher/remotesubmatch.h\
         matcher/selectpostlist.h\
+        matcher/synonympostlist.h\
         matcher/valuegepostlist.h\
         matcher/valuerangepostlist.h\
         matcher/xorpostlist.h
@@ -54 +55 @@
         matcher/queryoptimiser.cc\
         matcher/rset.cc\
         matcher/selectpostlist.cc\
+        matcher/synonympostlist.cc\
         matcher/valuegepostlist.cc\
         matcher/valuerangepostlist.cc\
         matcher/xorpostlist.cc

xapian-core/matcher/multimatch.cc

@@ -361 +361 @@
     }
     Assert(!postlists.empty());
 
+#ifdef XAPIAN_DEBUG_VERBOSE
+    {
+        LOGLINE(MATCH, "termfreqandwts:");
+        map<string, Xapian::MSet::Internal::TermFreqAndWeight>::const_iterator tfwi;
+        for (tfwi = termfreqandwts.begin(); tfwi != termfreqandwts.end(); ++tfwi)
+        {
+            LOGLINE(MATCH, "termfreqandwt[" << tfwi->first << "] = " << tfwi->second.termfreq << ", " << tfwi->second.termweight);
+        }
+    }
+#endif
+
     // Get a single combined postlist
     PostList *pl;
     if (postlists.size() == 1) {
@@ -783 +794 @@
                 LOGVALUE(MATCH, percent_scale);
                 Assert(percent_scale <= denom);
                 denom *= greatest_wt;
-                Assert(denom > 0);
-                percent_scale /= denom;
+                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;

xapian-core/matcher/localmatch.cc

@@ -31 +31 @@
 #include "omdebug.h"
 #include "omqueryinternal.h"
 #include "queryoptimiser.h"
+#include "synonympostlist.h"
 #include "weightinternal.h"
 
 #include <cfloat>
@@ -111 +112 @@
 }
 
 PostList *
+LocalSubMatch::make_synonym_postlist(PostList * or_pl, MultiMatch * matcher,
+                                     double factor)
+{
+    DEBUGCALL(MATCH, PostList *, "LocalSubMatch::make_synonym_postlist",
+              "[or_pl], [matcher], " << factor);
+    LOGLINE(MATCH, "or_pl->get_termfreq() = " << or_pl->get_termfreq_est());
+    AutoPtr<SynonymPostList> res(new SynonymPostList(or_pl, matcher));
+    AutoPtr<Xapian::Weight> wt(wt_factory->clone_());
+
+    wt->init_(*stats, qlen, "", 1, factor,
+              or_pl->get_termfreq_est(),
+              0 // FIXME - calculate the reltermfreq to use
+              );
+
+    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());
@@ -132 +152 @@
         Xapian::doccount tf = stats->get_termfreq(query->tname);
         Xapian::weight weight = boolean ? 0 : wt->get_maxpart();
         Xapian::MSet::Internal::TermFreqAndWeight info(tf, weight);
+        LOGLINE(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);
+        LOGLINE(MATCH, "Increasing term_info[" << query->tname << "] to (" << i->second.termfreq << ", " << i->second.termweight << ")");
     }
 
     LeafPostList * pl = db->open_post_list(query->tname);

xapian-core/matcher/localmatch.h

@@ -82 +82 @@
     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,
+                                     double factor);
+
     /** Convert an OP_LEAF query to a PostList.
      *
      *  This is called by QueryOptimiser when it reaches an OP_LEAF query.

xapian-core/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 <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::termcount 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 */

xapian-core/matcher/queryoptimiser.cc

@@ -54 +54 @@
 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);
@@ -121 +121 @@
             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) {
+    if (query->tname.empty()) factor = 0.0;
+    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_)
@@ -144 +154 @@
 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;
@@ -194 +204 @@
                             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));
@@ -297 +308 @@
 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);
@@ -381 +398 @@
                   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?
+
+    RETURN(localsubmatch.make_synonym_postlist(do_or_like(query, 0.0),
+                                               matcher, factor));
+}

xapian-core/matcher/queryoptimiser.h

@@ -62 +62 @@
      *
      *  @return         A PostList.
      */
-    PostList * do_leaf(const Xapian::Query::Internal * query, double factor) {
-        if (query->tname.empty()) factor = 0.0;
-        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 +98 @@
      */
     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_,

xapian-core/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::termcount 
+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() + ")";
+}

xapian-core/weight/weight.cc

@@ -73 +73 @@
     init(factor);
 }
 
+void
+Weight::init_(const Internal & stats, Xapian::termcount query_length,
+              const string & term, Xapian::termcount wqf, double factor,
+              Xapian::doccount termfreq,
+              Xapian::doccount reltermfreq)
+{
+    collection_size_ = stats.collection_size;
+    rset_size_ = stats.rset_size;
+    average_length_ = stats.get_average_length();
+    doclength_upper_bound_ = stats.db.get_doclength_upper_bound();
+    doclength_lower_bound_ = stats.db.get_doclength_lower_bound();
+    wdf_upper_bound_ = stats.db.get_wdf_upper_bound(term);
+    termfreq_ = termfreq;
+    reltermfreq_ = reltermfreq;
+    query_length_ = query_length;
+    wqf_ = wqf;
+    init(factor);
+}
+
 Weight::~Weight() { }
 
 }

xapian-core/tests/api_db.cc

@@ -1457 +1457 @@
     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 most of the weights for items in the "or" mset are
+         * different from those in the "synonym" mset. */
+        int same_weight = 0;
+        int different_weight = 0;
+        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 (values_or[did] == values_synonym[did]) {
+                same_weight += 1;
+            } else {
+                different_weight += 1;
+            }
+        }
+        if (qlist->size() == 1) {
+            // Had a single term - check that all the weights were the same.
+            TEST_EQUAL(different_weight, 0);
+            TEST_NOT_EQUAL(same_weight, 0);
+        } else {
+            // Check that most of the weights differ.
+            TEST_NOT_EQUAL(different_weight, 0);
+            TEST_REL(same_weight, <, different_weight);
+        }
+    }
+    return true;
+}
+
+// Regression test - test a synonym search with a MultiAndPostlist.
+DEFINE_TESTCASE(synonym2, backend) {
+    Xapian::Query query;
+    vector<Xapian::Query> subqueries;
+    subqueries.push_back(Xapian::Query("file"));
+    subqueries.push_back(Xapian::Query("the"));
+    subqueries.push_back(Xapian::Query("next"));
+    subqueries.push_back(Xapian::Query("reader"));
+    query = Xapian::Query(Xapian::Query::OP_AND, subqueries.begin(), subqueries.end());
+    subqueries.clear();
+    subqueries.push_back(query);
+    subqueries.push_back(Xapian::Query("gutenberg"));
+    query = Xapian::Query(Xapian::Query::OP_SYNONYM, subqueries.begin(), subqueries.end());
+
+    tout << query.get_description() << endl;
+
+    Xapian::Database db(get_database("etext"));
+    Xapian::Enquire enquire(db);
+    enquire.set_query(query);
+    Xapian::MSet mset = enquire.get_mset(0, 10);
+    tout << mset.get_description() << endl;
+
+    // Regression test that OP_SCALE_WEIGHT works with OP_SYNONYM
+    double maxposs = mset.get_max_possible();
+    query = Xapian::Query(Xapian::Query::OP_SCALE_WEIGHT, query, 10.0);
+    enquire.set_query(query);
+    mset = enquire.get_mset(0, 10);
+    double maxposs2 = mset.get_max_possible();
+
+    TEST_EQUAL_DOUBLE(maxposs * 10.0, maxposs2);
+
+    return true;
+}
+
 // tests that specifying a nonexistent input file throws an exception.
 DEFINE_TESTCASE(flintdatabaseopeningerror1, flint) {
     mkdir(".flint", 0755);

xapian-core/tests/queryparsertest.cc

@@ -786 +786 @@
     Xapian::Query qobj = qp.parse_query("ab*", Xapian::QueryParser::FLAG_WILDCARD);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(abc:(pos=1))");
     qobj = qp.parse_query("muscle*", Xapian::QueryParser::FLAG_WILDCARD);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscle:(pos=1) OR musclebound:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscle:(pos=1) SYNONYM musclebound:(pos=1)))");
     qobj = qp.parse_query("meat*", Xapian::QueryParser::FLAG_WILDCARD);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query()");
     qobj = qp.parse_query("musc*", Xapian::QueryParser::FLAG_WILDCARD);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscat:(pos=1) OR muscle:(pos=1) OR musclebound:(pos=1) OR muscular:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscat:(pos=1) SYNONYM muscle:(pos=1) SYNONYM musclebound:(pos=1) SYNONYM muscular:(pos=1)))");
     qobj = qp.parse_query("mutt*", Xapian::QueryParser::FLAG_WILDCARD);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(mutton:(pos=1))");
     // Regression test (we weren't lowercasing terms before checking if they
@@ -879 +879 @@
     qp.add_prefix("author", "A");
     Xapian::Query qobj;
     qobj = qp.parse_query("author:h*", Xapian::QueryParser::FLAG_WILDCARD);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((Aheinlein:(pos=1) OR Ahuxley:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((Aheinlein:(pos=1) SYNONYM Ahuxley:(pos=1)))");
     qobj = qp.parse_query("author:h* test", Xapian::QueryParser::FLAG_WILDCARD);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((Aheinlein:(pos=1) OR Ahuxley:(pos=1) OR test:(pos=2)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((Aheinlein:(pos=1) SYNONYM Ahuxley:(pos=1)) OR test:(pos=2)))");
     return true;
 }
 
@@ -922 +922 @@
     qobj = qp.parse_query("ab", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((abc:(pos=1) OR Zab:(pos=1)))");
     qobj = qp.parse_query("muscle", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscle:(pos=1) OR musclebound:(pos=1) OR Zmuscl:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((muscle:(pos=1) SYNONYM musclebound:(pos=1)) OR Zmuscl:(pos=1)))");
     qobj = qp.parse_query("meat", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(Zmeat:(pos=1))");
     qobj = qp.parse_query("musc", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((muscat:(pos=1) OR muscle:(pos=1) OR musclebound:(pos=1) OR muscular:(pos=1) OR Zmusc:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((muscat:(pos=1) SYNONYM muscle:(pos=1) SYNONYM musclebound:(pos=1) SYNONYM muscular:(pos=1)) OR Zmusc:(pos=1)))");
     qobj = qp.parse_query("mutt", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((mutton:(pos=1) OR Zmutt:(pos=1)))");
     qobj = qp.parse_query("abc musc", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((Zabc:(pos=1) OR muscat:(pos=2) OR muscle:(pos=2) OR musclebound:(pos=2) OR muscular:(pos=2) OR Zmusc:(pos=2)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((Zabc:(pos=1) OR (muscat:(pos=2) SYNONYM muscle:(pos=2) SYNONYM musclebound:(pos=2) SYNONYM muscular:(pos=2)) OR Zmusc:(pos=2)))");
     qobj = qp.parse_query("a* mutt", Xapian::QueryParser::FLAG_PARTIAL | Xapian::QueryParser::FLAG_WILDCARD);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((abc:(pos=1) OR mutton:(pos=2) OR Zmutt:(pos=2)))");
 
     // Check behaviour with stemmed terms, and stem strategy STEM_SOME.
     qobj = qp.parse_query("o", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((out:(pos=1) OR outside:(pos=1) OR Zo:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((out:(pos=1) SYNONYM outside:(pos=1)) OR Zo:(pos=1)))");
     qobj = qp.parse_query("ou", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((out:(pos=1) OR outside:(pos=1) OR Zou:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((out:(pos=1) SYNONYM outside:(pos=1)) OR Zou:(pos=1)))");
     qobj = qp.parse_query("out", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((out:(pos=1) OR outside:(pos=1) OR Zout:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((out:(pos=1) SYNONYM outside:(pos=1)) OR Zout:(pos=1)))");
     qobj = qp.parse_query("outs", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((outside:(pos=1) OR Zout:(pos=1)))");
     qobj = qp.parse_query("outsi", Xapian::QueryParser::FLAG_PARTIAL);
@@ -952 +952 @@
 
     // Check behaviour with capitalised terms, and stem strategy STEM_SOME.
     qobj = qp.parse_query("Out", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((out:(pos=1,wqf=2) OR outside:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((out:(pos=1) SYNONYM outside:(pos=1)) OR out:(pos=1)))");
     qobj = qp.parse_query("Outs", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((outside:(pos=1) OR outs:(pos=1)))");
     qobj = qp.parse_query("Outside", Xapian::QueryParser::FLAG_PARTIAL);
@@ -961 +961 @@
     // And now with stemming strategy STEM_ALL.
     qp.set_stemming_strategy(Xapian::QueryParser::STEM_ALL);
     qobj = qp.parse_query("Out", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((out:(pos=1,wqf=2) OR outside:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((out:(pos=1) SYNONYM outside:(pos=1)) OR out:(pos=1)))");
     qobj = qp.parse_query("Outs", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((outside:(pos=1) OR out:(pos=1)))");
     qobj = qp.parse_query("Outside", Xapian::QueryParser::FLAG_PARTIAL);
@@ -970 +970 @@
     // Check handling of a case with a prefix.
     qp.set_stemming_strategy(Xapian::QueryParser::STEM_SOME);
     qobj = qp.parse_query("title:cow", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((XTcowl:(pos=1) OR XTcows:(pos=1) OR ZXTcow:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((XTcowl:(pos=1) SYNONYM XTcows:(pos=1)) OR ZXTcow:(pos=1)))");
     qobj = qp.parse_query("title:cows", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((XTcows:(pos=1) OR ZXTcow:(pos=1)))");
     qobj = qp.parse_query("title:Cow", Xapian::QueryParser::FLAG_PARTIAL);
-    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query((XTcowl:(pos=1) OR XTcows:(pos=1) OR XTcow:(pos=1)))");
+    TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(((XTcowl:(pos=1) SYNONYM XTcows:(pos=1)) OR XTcow:(pos=1)))");
     qobj = qp.parse_query("title:Cows", Xapian::QueryParser::FLAG_PARTIAL);
     TEST_STRINGS_EQUAL(qobj.get_description(), "Xapian::Query(XTcows:(pos=1,wqf=2))");
 
@@ -1547 +1547 @@
 }
 
 static test test_synonym_queries[] = {
-    { "searching", "(Zsearch:(pos=1) OR Zfind:(pos=1) OR Zlocate:(pos=1))" },
-    { "search", "(Zsearch:(pos=1) OR find:(pos=1))" },
-    { "Search", "(search:(pos=1) OR find:(pos=1))" },
+    { "searching", "(Zsearch:(pos=1) SYNONYM Zfind:(pos=1) SYNONYM Zlocate:(pos=1))" },
+    { "search", "(Zsearch:(pos=1) SYNONYM find:(pos=1))" },
+    { "Search", "(search:(pos=1) SYNONYM find:(pos=1))" },
     { "Searching", "searching:(pos=1)" },
-    { "searching OR terms", "(Zsearch:(pos=1) OR Zfind:(pos=1) OR Zlocate:(pos=1) OR Zterm:(pos=2))" },
-    { "search OR terms", "(Zsearch:(pos=1) OR find:(pos=1) OR Zterm:(pos=2))" },
-    { "search +terms", "(Zterm:(pos=2) AND_MAYBE (Zsearch:(pos=1) OR find:(pos=1)))" },
-    { "search -terms", "((Zsearch:(pos=1) OR find:(pos=1)) AND_NOT Zterm:(pos=2))" },
-    { "+search terms", "((Zsearch:(pos=1) OR find:(pos=1)) AND_MAYBE Zterm:(pos=2))" },
-    { "-search terms", "(Zterm:(pos=2) AND_NOT (Zsearch:(pos=1) OR find:(pos=1)))" },
-    { "search terms", "(Zsearch:(pos=1) OR find:(pos=1) OR Zterm:(pos=2))" },
+    { "searching OR terms", "((Zsearch:(pos=1) SYNONYM Zfind:(pos=1) SYNONYM Zlocate:(pos=1)) OR Zterm:(pos=2))" },
+    { "search OR terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) OR Zterm:(pos=2))" },
+    { "search +terms", "(Zterm:(pos=2) AND_MAYBE (Zsearch:(pos=1) SYNONYM find:(pos=1)))" },
+    { "search -terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) AND_NOT Zterm:(pos=2))" },
+    { "+search terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) AND_MAYBE Zterm:(pos=2))" },
+    { "-search terms", "(Zterm:(pos=2) AND_NOT (Zsearch:(pos=1) SYNONYM find:(pos=1)))" },
+    { "search terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) OR Zterm:(pos=2))" },
     // Shouldn't trigger synonyms:
     { "\"search terms\"", "(search:(pos=1) PHRASE 2 terms:(pos=2))" },
     { NULL, NULL }
@@ -1597 +1597 @@
 
 static test test_multi_synonym_queries[] = {
     { "sun OR tan OR cream", "(Zsun:(pos=1) OR Ztan:(pos=2) OR Zcream:(pos=3))" },
-    { "sun tan", "(Zsun:(pos=1) OR Ztan:(pos=2) OR bathe:(pos=1))" },
-    { "sun tan cream", "(Zsun:(pos=1) OR Ztan:(pos=2) OR Zcream:(pos=3) OR lotion:(pos=1))" },
-    { "beach sun tan holiday", "(Zbeach:(pos=1) OR Zsun:(pos=2) OR Ztan:(pos=3) OR bathe:(pos=2) OR Zholiday:(pos=4))" },
-    { "sun tan sun tan cream", "(Zsun:(pos=1) OR Ztan:(pos=2) OR bathe:(pos=1) OR Zsun:(pos=3) OR Ztan:(pos=4) OR Zcream:(pos=5) OR lotion:(pos=3))" },
-    { "single", "(Zsingl:(pos=1) OR record:(pos=1))" },
+    { "sun tan", "((Zsun:(pos=1) OR Ztan:(pos=2)) SYNONYM bathe:(pos=1))" },
+    { "sun tan cream", "((Zsun:(pos=1) OR Ztan:(pos=2) OR Zcream:(pos=3)) SYNONYM lotion:(pos=1))" },
+    { "beach sun tan holiday", "(Zbeach:(pos=1) OR ((Zsun:(pos=2) OR Ztan:(pos=3)) SYNONYM bathe:(pos=2)) OR Zholiday:(pos=4))" },
+    { "sun tan sun tan cream", "(((Zsun:(pos=1) OR Ztan:(pos=2)) SYNONYM bathe:(pos=1)) OR ((Zsun:(pos=3) OR Ztan:(pos=4) OR Zcream:(pos=5)) SYNONYM lotion:(pos=3)))" },
+    { "single", "(Zsingl:(pos=1) SYNONYM record:(pos=1))" },
     { NULL, NULL }
 };
 
@@ -1640 +1640 @@
 
 static test test_synonym_op_queries[] = {
     { "searching", "Zsearch:(pos=1)" },
-    { "~searching", "(Zsearch:(pos=1) OR Zfind:(pos=1) OR Zlocate:(pos=1))" },
-    { "~search", "(Zsearch:(pos=1) OR find:(pos=1))" },
-    { "~Search", "(search:(pos=1) OR find:(pos=1))" },
+    { "~searching", "(Zsearch:(pos=1) SYNONYM Zfind:(pos=1) SYNONYM Zlocate:(pos=1))" },
+    { "~search", "(Zsearch:(pos=1) SYNONYM find:(pos=1))" },
+    { "~Search", "(search:(pos=1) SYNONYM find:(pos=1))" },
     { "~Searching", "searching:(pos=1)" },
-    { "~searching OR terms", "(Zsearch:(pos=1) OR Zfind:(pos=1) OR Zlocate:(pos=1) OR Zterm:(pos=2))" },
-    { "~search OR terms", "(Zsearch:(pos=1) OR find:(pos=1) OR Zterm:(pos=2))" },
-    { "~search +terms", "(Zterm:(pos=2) AND_MAYBE (Zsearch:(pos=1) OR find:(pos=1)))" },
-    { "~search -terms", "((Zsearch:(pos=1) OR find:(pos=1)) AND_NOT Zterm:(pos=2))" },
-    { "+~search terms", "((Zsearch:(pos=1) OR find:(pos=1)) AND_MAYBE Zterm:(pos=2))" },
-    { "-~search terms", "(Zterm:(pos=2) AND_NOT (Zsearch:(pos=1) OR find:(pos=1)))" },
-    { "~search terms", "(Zsearch:(pos=1) OR find:(pos=1) OR Zterm:(pos=2))" },
+    { "~searching OR terms", "((Zsearch:(pos=1) SYNONYM Zfind:(pos=1) SYNONYM Zlocate:(pos=1)) OR Zterm:(pos=2))" },
+    { "~search OR terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) OR Zterm:(pos=2))" },
+    { "~search +terms", "(Zterm:(pos=2) AND_MAYBE (Zsearch:(pos=1) SYNONYM find:(pos=1)))" },
+    { "~search -terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) AND_NOT Zterm:(pos=2))" },
+    { "+~search terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) AND_MAYBE Zterm:(pos=2))" },
+    { "-~search terms", "(Zterm:(pos=2) AND_NOT (Zsearch:(pos=1) SYNONYM find:(pos=1)))" },
+    { "~search terms", "((Zsearch:(pos=1) SYNONYM find:(pos=1)) OR Zterm:(pos=2))" },
     // FIXME: should look for multi-term synonym...
     { "~\"search terms\"", "(search:(pos=1) PHRASE 2 terms:(pos=2))" },
     { NULL, NULL }

xapian-core/include/xapian/query.h

@@ -119 +119 @@
             OP_VALUE_GE,
 
             /** Filter by a less-than-or-equal test on a document value. */
-            OP_VALUE_LE
+            OP_VALUE_LE,
+
+            /** 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. */

xapian-core/include/xapian/weight.h

@@ -212 +212 @@
                const std::string & term, Xapian::termcount wqf_,
                double factor);
 
+    /** @private @internal Initialise this object to calculate weights for term
+     *  @a term, with explicit termfreq and reltermfreq.
+     *
+     *  @param stats       Source of statistics.
+     *  @param query_len_  Query length.
+     *  @param term        The term for the new object.
+     *  @param wqf_        The within-query-frequency of @a term.
+     *  @param factor      Any scaling factor (e.g. from OP_SCALE_WEIGHT).
+     *  @param termfreq    The termfreq to use.
+     *  @param reltermfreq The reltermfreq to use.
+     */
+    void init_(const Internal & stats, Xapian::termcount query_len_,
+               const std::string & term, Xapian::termcount wqf_,
+               double factor,
+               Xapian::doccount termfreq,
+               Xapian::doccount reltermfreq);
+
     /** @private @internal Initialise this object to calculate the extra weight
      *  term.
      *

xapian-core/api/omqueryinternal.cc

@@ -65 +65 @@
         case Xapian::Query::OP_VALUE_RANGE:
         case Xapian::Query::OP_VALUE_GE:
         case Xapian::Query::OP_VALUE_LE:
+        case Xapian::Query::OP_SYNONYM:
             return 0;
         case Xapian::Query::OP_SCALE_WEIGHT:
             return 1;
@@ -100 +101 @@
         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);
@@ -221 +223 @@
                 result += ".";
                 result += str_parameter; // serialise_double(get_dbl_parameter());
                 break;
+            case Xapian::Query::OP_SYNONYM:
+                result += "=";
+                break;
         }
     }
     return result;
@@ -251 +256 @@
         case Xapian::Query::OP_VALUE_GE:        name = "VALUE_GE"; break;
         case Xapian::Query::OP_VALUE_LE:        name = "VALUE_LE"; break;
         case Xapian::Query::OP_SCALE_WEIGHT:    name = "SCALE_WEIGHT"; break;
+        case Xapian::Query::OP_SYNONYM:         name = "SYNONYM"; break;
     }
     return name;
 }
@@ -584 +590 @@
                     return qint_from_vector(Xapian::Query::OP_SCALE_WEIGHT,
                                             subqs, 0, param);
                 }
-                default:
+                case '=': {
+                    return qint_from_vector(Xapian::Query::OP_SYNONYM, subqs);
+                }
+                default:
                     LOGLINE(UNKNOWN, "Can't parse remainder `" << p - 1 << "'");
                     throw Xapian::InvalidArgumentError("Invalid query string");
             }
@@ -809 +818 @@
         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
@@ -900 +910 @@
                 }
             }
             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;
@@ -944 +954 @@
 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;
 
@@ -1038 +1048 @@
     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++) {