ferret 0.11.6 → 0.11.8.4

data/ext/search.c

@@ -2,10 +2,11 @@
 #include <limits.h>
 #include "search.h"
 #include "array.h"
+#include "internal.h"
 
 /***************************************************************************
  *
- * Explanation
+ * Explanation - Used to give details for query scores
  *
  ***************************************************************************/
 
@@ -46,7 +47,8 @@ char *expl_to_s_depth(Explanation *expl, int depth)
     memset(buffer, ' ', sizeof(char) * depth * 2);
     buffer[depth*2] = 0;
 
-    buffer = estrcat(buffer, strfmt("%f = %s\n", expl->value, expl->description));
+    buffer = estrcat(buffer, strfmt("%f = %s\n",
+                                    expl->value, expl->description));
     for (i = 0; i < num_details; i++) {
         buffer = estrcat(buffer, expl_to_s_depth(expl->details[i], depth + 1));
     }
@@ -300,7 +302,7 @@ static const char *QUERY_NAMES[] = {
 
 static const char *UNKNOWN_QUERY_NAME = "UnkownQuery";
     
-const char *q_get_query_name(enum QUERY_TYPE type) {
+const char *q_get_query_name(QueryType type) {
     if (type >= NELEMS(QUERY_NAMES)) {
         return UNKNOWN_QUERY_NAME;
     }
@@ -401,13 +403,14 @@ Query *q_combine(Query **queries, int q_cnt)
         }
     }
     if (uniques->size == 1) {
-        ret_q = (Query *)uniques->elems[0]; 
+        ret_q = (Query *)uniques->first->elem; 
         REF(ret_q);
     }
     else {
+        HashSetEntry *hse;
         ret_q = bq_new(true);
-        for (i = 0; i < uniques->size; i++) {
-            q = (Query *)uniques->elems[i];
+        for (hse = uniques->first; hse; hse = hse->next) {
+            q = (Query *)hse->elem;
             bq_add_query(ret_q, q, BC_SHOULD);
         }
     }
@@ -441,8 +444,8 @@ Query *q_create(size_t size)
     Query *self = (Query *)ecalloc(size);
 #ifdef DEBUG
     if (size < sizeof(Query)) {
-        RAISE(FERRET_ERROR, "Size of a query <%d> should never be smaller than the "
-              "size of a Query struct <%d>", (int)size, (int)sizeof(Query));
+        RAISE(FERRET_ERROR, "Size of a query <%d> should never be smaller than "
+              "the size of a Query struct <%d>", (int)size, (int)sizeof(Query));
     }
 #endif
     self->boost             = 1.0;
@@ -536,8 +539,9 @@ MatchVector *matchv_add(MatchVector *self, int start, int end)
         REALLOC_N(self->matches, MatchRange, self->capa);
     }
     self->matches[self->size].start = start;
-    self->matches[self->size].end = end;
-    self->matches[self->size++].score = 1.0;
+    self->matches[self->size].end   = end;
+    self->matches[self->size].score = 1.0;
+    self->size++;
     return self;
 }
 
@@ -620,7 +624,7 @@ void matchv_destroy(MatchVector *self)
 MatchVector *searcher_get_match_vector(Searcher *self,
                                        Query *query,
                                        const int doc_num,
-                                       const char *field)
+                                       Symbol field)
 {
     MatchVector *mv = matchv_new();
     bool rewrite = query->get_matchv_i == q_get_matchv_i;
@@ -832,7 +836,7 @@ static char *highlight_field(MatchVector *mv,
 char **searcher_highlight(Searcher *self,
                           Query *query,
                           const int doc_num,
-                          const char *field,
+                          Symbol field,
                           const int excerpt_len,
                           const int num_excerpts,
                           const char *pre_tag,
@@ -844,7 +848,7 @@ char **searcher_highlight(Searcher *self,
     LazyDoc *lazy_doc = self->get_lazy_doc(self, doc_num);
     LazyDocField *lazy_df = NULL;
     if (lazy_doc) {
-        lazy_df = h_get(lazy_doc->field_dict, field);
+        lazy_df = lazy_doc_get(lazy_doc, field);
     }
     if (tv && lazy_df && tv->term_cnt > 0 && tv->terms[0].positions != NULL
         && tv->offsets != NULL) {
@@ -888,7 +892,7 @@ char **searcher_highlight(Searcher *self,
             }
 
             for (i = 0; i < num_excerpts && excerpt_pq->size > 0; i++) {
-                excerpts[i] = pq_pop(excerpt_pq);
+                excerpts[i] = (Excerpt *)pq_pop(excerpt_pq);
                 if (i < num_excerpts - 1) {
                     /* set match ranges alread included to 0 */
                     Excerpt *e = excerpts[i];
@@ -897,7 +901,7 @@ char **searcher_highlight(Searcher *self,
                     }
                     e = NULL;
                     while (e != (Excerpt *)pq_top(excerpt_pq)) {
-                        e = pq_top(excerpt_pq);
+                        e = (Excerpt *)pq_top(excerpt_pq);
                         excerpt_recalc_score(e, mv);
                         pq_down(excerpt_pq);
                     }
@@ -990,7 +994,7 @@ static Similarity *sea_get_similarity(Searcher *self)
 
 #define ISEA(searcher) ((IndexSearcher *)(searcher))
 
-int isea_doc_freq(Searcher *self, const char *field, const char *term)
+int isea_doc_freq(Searcher *self, Symbol field, const char *term)
 {
     return ir_doc_freq(ISEA(self)->ir, field, term);
 }
@@ -1013,10 +1017,12 @@ static int isea_max_doc(Searcher *self)
     return ir->max_doc(ir);
 }
 
-#define IS_FILTERED(bits, filter_func, scorer, searcher) \
+#define IS_FILTERED(bits, post_filter, scorer, searcher) \
 ((bits && !bv_get(bits, scorer->doc))\
- || (filter_func \
-     && !filter_func(scorer->doc, scorer->score(scorer), searcher)))
+ || (post_filter \
+     && !(filter_factor = \
+          post_filter->filter_func(scorer->doc, scorer->score(scorer),\
+                                   searcher, post_filter->arg))))
 
 static TopDocs *isea_search_w(Searcher *self,
                               Weight *weight,
@@ -1024,7 +1030,7 @@ static TopDocs *isea_search_w(Searcher *self,
                               int num_docs,
                               Filter *filter,
                               Sort *sort,
-                              filter_ft filter_func,
+                              PostFilter *post_filter,
                               bool load_fields)
 {
     int max_size = num_docs + (num_docs == INT_MAX ? 0 : first_doc);
@@ -1034,6 +1040,7 @@ static TopDocs *isea_search_w(Searcher *self,
     Hit hit;
     int total_hits = 0;
     float score, max_score = 0.0;
+    float filter_factor = 1.0;
     BitVector *bits = (filter
                        ? filt_get_bv(filter, ISEA(self)->ir)
                        : NULL);
@@ -1069,11 +1076,17 @@ static TopDocs *isea_search_w(Searcher *self,
     }
 
     while (scorer->next(scorer)) {
-        if (IS_FILTERED(bits, filter_func, scorer, self)) {
+        if (bits && !bv_get(bits, scorer->doc)) continue;
+        score = scorer->score(scorer);
+        if (post_filter &&
+            !(filter_factor = post_filter->filter_func(scorer->doc,
+                                                       score,
+                                                       self,
+                                                       post_filter->arg))) {
             continue;
         }
         total_hits++;
-        score = scorer->score(scorer);
+        if (filter_factor < 1.0) score *= filter_factor;
         if (score > max_score) max_score = score;
         hit.doc = scorer->doc; hit.score = score;
         hq_insert(hq, &hit);
@@ -1108,23 +1121,24 @@ static TopDocs *isea_search(Searcher *self,
                             int num_docs,
                             Filter *filter,
                             Sort *sort,
-                            filter_ft filter_func,
+                            PostFilter *post_filter,
                             bool load_fields)
 {
     TopDocs *td;
     Weight *weight = q_weight(query, self);
     td = isea_search_w(self, weight, first_doc, num_docs, filter,
-                         sort, filter_func, load_fields);
+                         sort, post_filter, load_fields);
     weight->destroy(weight);
     return td;
 }
 
 static void isea_search_each_w(Searcher *self, Weight *weight, Filter *filter,
-                               filter_ft filter_func,
+                               PostFilter *post_filter,
                                void (*fn)(Searcher *, int, float, void *),
                                void *arg)
 {
     Scorer *scorer;
+    float filter_factor = 1.0;
     BitVector *bits = (filter
                        ? filt_get_bv(filter, ISEA(self)->ir)
                        : NULL);
@@ -1135,24 +1149,70 @@ static void isea_search_each_w(Searcher *self, Weight *weight, Filter *filter,
     }
 
     while (scorer->next(scorer)) {
-        if (IS_FILTERED(bits, filter_func, scorer, self)) {
+        if (bits && !bv_get(bits, scorer->doc)) continue;
+        float score = scorer->score(scorer);
+        if (post_filter &&
+            !(filter_factor = post_filter->filter_func(scorer->doc,
+                                                       score,
+                                                       self,
+                                                       post_filter->arg))) {
             continue;
         }
-        fn(self, scorer->doc, scorer->score(scorer), arg);
+        fn(self, scorer->doc, filter_factor * score, arg);
     }
     scorer->destroy(scorer);
 }
 
 static void isea_search_each(Searcher *self, Query *query, Filter *filter,
-                             filter_ft filter_func,
+                             PostFilter *post_filter,
                              void (*fn)(Searcher *, int, float, void *),
                              void *arg)
 {
     Weight *weight = q_weight(query, self);
-    isea_search_each_w(self, weight, filter, filter_func, fn, arg);
+    isea_search_each_w(self, weight, filter, post_filter, fn, arg);
     weight->destroy(weight);
 }
 
+/*
+ * Scan the index for all documents that match a query and write the results
+ * to a buffer. It will stop scanning once the limit is reached and it starts
+ * scanning from offset_docnum. 
+ *
+ * Note: Unlike the offset_docnum in other search methods, this offset_docnum
+ * refers to document number and not hit.
+ */
+static int isea_search_unscored_w(Searcher *self,
+                                  Weight *weight,
+                                  int *buf,
+                                  int limit,
+                                  int offset_docnum)
+{
+    int count = 0;
+    Scorer *scorer = weight->scorer(weight, ISEA(self)->ir);
+    if (scorer) {
+        if (scorer->skip_to(scorer, offset_docnum)) {
+            do {
+                buf[count++] = scorer->doc;
+            } while (count < limit && scorer->next(scorer));
+        }
+        scorer->destroy(scorer);
+    }
+    return count;
+}
+
+static int isea_search_unscored(Searcher *self,
+                                Query *query,
+                                int *buf,
+                                int limit,
+                                int offset_docnum)
+{
+    int count;
+    Weight *weight = q_weight(query, self);
+    count = isea_search_unscored_w(self, weight, buf, limit, offset_docnum);
+    weight->destroy(weight);
+    return count;
+}
+
 static Query *isea_rewrite(Searcher *self, Query *original)
 {
     int q_is_destroyed = false;
@@ -1167,7 +1227,9 @@ static Query *isea_rewrite(Searcher *self, Query *original)
     return query;
 }
 
-static Explanation *isea_explain(Searcher *self, Query *query, int doc_num)
+static Explanation *isea_explain(Searcher *self,
+                                 Query *query,
+                                 int doc_num)
 {
     Weight *weight = q_weight(query, self);
     Explanation *e =  weight->explain(weight, ISEA(self)->ir, doc_num);
@@ -1182,7 +1244,7 @@ static Explanation *isea_explain_w(Searcher *self, Weight *w, int doc_num)
 
 static TermVector *isea_get_term_vector(Searcher *self,
                                           const int doc_num,
-                                          const char *field)
+                                          Symbol field)
 {
     IndexReader *ir = ISEA(self)->ir;
     return ir->term_vector(ir, doc_num, field);
@@ -1198,7 +1260,7 @@ static void isea_close(Searcher *self)
 
 Searcher *isea_new(IndexReader *ir)
 {
-    Searcher *self          = (Searcher *)ecalloc(sizeof(IndexSearcher));
+    Searcher *self          = (Searcher *)ALLOC(IndexSearcher);
 
     ISEA(self)->ir          = ir;
     ISEA(self)->close_ir    = true;
@@ -1213,6 +1275,8 @@ Searcher *isea_new(IndexReader *ir)
     self->search_w          = &isea_search_w;
     self->search_each       = &isea_search_each;
     self->search_each_w     = &isea_search_each_w;
+    self->search_unscored   = &isea_search_unscored;
+    self->search_unscored_w = &isea_search_unscored_w;
     self->rewrite           = &isea_rewrite;
     self->explain           = &isea_explain;
     self->explain_w         = &isea_explain_w;
@@ -1232,16 +1296,16 @@ Searcher *isea_new(IndexReader *ir)
 #define CDFSEA(searcher) ((CachedDFSearcher *)(searcher))
 typedef struct CachedDFSearcher
 {
-    Searcher    super;
-    HashTable  *df_map;
-    int         max_doc;
+    Searcher super;
+    Hash     *df_map;
+    int      max_doc;
 } CachedDFSearcher;
 
-static int cdfsea_doc_freq(Searcher *self, const char *field, const char *text)
+static int cdfsea_doc_freq(Searcher *self, Symbol field, const char *text)
 {
     Term term;
     int *df;
-    term.field = (char *)field;
+    term.field = field;
     term.text = (char *)text;
     df = (int *)h_get(CDFSEA(self)->df_map, &term);
     return df ? *df : 0;
@@ -1250,7 +1314,7 @@ static int cdfsea_doc_freq(Searcher *self, const char *field, const char *text)
 static Document *cdfsea_get_doc(Searcher *self, int doc_num)
 {
     (void)self; (void)doc_num;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
@@ -1263,44 +1327,44 @@ static int cdfsea_max_doc(Searcher *self)
 static Weight *cdfsea_create_weight(Searcher *self, Query *query)
 {
     (void)self; (void)query;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static TopDocs *cdfsea_search_w(Searcher *self, Weight *w, int fd, int nd,
-                                Filter *f, Sort *s, filter_ft ff, bool load)
+                                Filter *f, Sort *s, PostFilter *pf, bool load)
 {
     (void)self; (void)w; (void)fd; (void)nd;
-    (void)f; (void)s; (void)ff; (void)load;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)f; (void)s; (void)pf; (void)load;
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static TopDocs *cdfsea_search(Searcher *self, Query *q, int fd, int nd,
-                              Filter *f, Sort *s, filter_ft ff, bool load)
+                              Filter *f, Sort *s, PostFilter *pf, bool load)
 {
     (void)self; (void)q; (void)fd; (void)nd;
-    (void)f; (void)s; (void)ff; (void)load;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)f; (void)s; (void)pf; (void)load;
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static void cdfsea_search_each(Searcher *self, Query *query, Filter *filter,
-                               filter_ft ff, 
+                               PostFilter *pf, 
                                void (*fn)(Searcher *, int, float, void *),
                                void *arg)
 {
-    (void)self; (void)query; (void)filter; (void)ff; (void)fn; (void)arg;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)self; (void)query; (void)filter; (void)pf; (void)fn; (void)arg;
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
 }
 
 static void cdfsea_search_each_w(Searcher *self, Weight *w, Filter *filter,
-                                 filter_ft ff, 
+                                 PostFilter *pf, 
                                  void (*fn)(Searcher *, int, float, void *),
                                  void *arg)
 {
-    (void)self; (void)w; (void)filter; (void)ff; (void)fn; (void)arg;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    (void)self; (void)w; (void)filter; (void)pf; (void)fn; (void)arg;
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
 }
 
 static Query *cdfsea_rewrite(Searcher *self, Query *original)
@@ -1313,30 +1377,28 @@ static Query *cdfsea_rewrite(Searcher *self, Query *original)
 static Explanation *cdfsea_explain(Searcher *self, Query *query, int doc_num)
 {
     (void)self; (void)query; (void)doc_num;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static Explanation *cdfsea_explain_w(Searcher *self, Weight *w, int doc_num)
 {
     (void)self; (void)w; (void)doc_num;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static TermVector *cdfsea_get_term_vector(Searcher *self, const int doc_num,
-                                          const char *field)
+                                          Symbol field)
 {
     (void)self; (void)doc_num; (void)field;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
+    RAISE(UNSUPPORTED_ERROR, "%s", UNSUPPORTED_ERROR_MSG);
     return NULL;
 }
 
 static Similarity *cdfsea_get_similarity(Searcher *self)
 {
-    (void)self;
-    RAISE(UNSUPPORTED_ERROR, UNSUPPORTED_ERROR_MSG);
-    return NULL;
+    return self->similarity;
 }
 
 static void cdfsea_close(Searcher *self)
@@ -1345,13 +1407,14 @@ static void cdfsea_close(Searcher *self)
     free(self);
 }
 
-static Searcher *cdfsea_new(HashTable *df_map, int max_doc)
+static Searcher *cdfsea_new(Hash *df_map, int max_doc)
 {
-    Searcher *self          = (Searcher *)ecalloc(sizeof(CachedDFSearcher));
+    Searcher *self          = (Searcher *)ALLOC(CachedDFSearcher);
 
     CDFSEA(self)->df_map    = df_map;
     CDFSEA(self)->max_doc   = max_doc;
 
+    self->similarity        = sim_create_default();
     self->doc_freq          = &cdfsea_doc_freq;
     self->get_doc           = &cdfsea_get_doc;
     self->max_doc           = &cdfsea_max_doc;
@@ -1403,7 +1466,7 @@ static INLINE int msea_get_searcher_index(Searcher *self, int n)
     return hi;
 }
 
-static int msea_doc_freq(Searcher *self, const char *field, const char *term)
+static int msea_doc_freq(Searcher *self, Symbol field, const char *term)
 {
     int i;
     int doc_freq = 0;
@@ -1440,10 +1503,10 @@ static int msea_max_doc(Searcher *self)
 static int *msea_get_doc_freqs(Searcher *self, HashSet *terms)
 {
     int i;
-    const int num_terms = terms->size;
-    int *doc_freqs = ALLOC_N(int, num_terms);
-    for (i = 0; i < num_terms; i++) {
-        Term *t = (Term *)terms->elems[i];
+    HashSetEntry *hse;
+    int *doc_freqs = ALLOC_N(int, terms->size);
+    for (i = 0, hse = terms->first; hse; ++i, hse = hse->next) {
+        Term *t = (Term *)hse->elem;
         doc_freqs[i] = msea_doc_freq(self, t->field, t->text);
     }
     return doc_freqs;
@@ -1454,16 +1517,22 @@ static Weight *msea_create_weight(Searcher *self, Query *query)
     int i, *doc_freqs;
     Searcher *cdfsea;
     Weight *w;
-    HashTable *df_map = h_new((hash_ft)&term_hash, (eq_ft)&term_eq,
-                             (free_ft)NULL, free);
+    Hash *df_map = h_new((hash_ft)&term_hash,
+                         (eq_ft)&term_eq,
+                         (free_ft)term_destroy,
+                         free);
     Query *rewritten_query = self->rewrite(self, query);
-    HashSet *terms = term_set_new();
+    /* terms get copied directly to df_map so no need to free here */
+    HashSet *terms = hs_new((hash_ft)&term_hash,
+                            (eq_ft)&term_eq,
+                            (free_ft)NULL);
+    HashSetEntry *hse;
 
     rewritten_query->extract_terms(rewritten_query, terms);
     doc_freqs = msea_get_doc_freqs(self, terms);
 
-    for (i = 0; i < terms->size; i++) {
-        h_set(df_map, terms->elems[i], imalloc(doc_freqs[i])); 
+    for (hse = terms->first, i = 0; hse; ++i, hse = hse->next) {
+        h_set(df_map, hse->elem, imalloc(doc_freqs[i])); 
     }
     hs_destroy(terms);
     free(doc_freqs);
@@ -1483,7 +1552,7 @@ struct MultiSearchEachArg {
     void (*fn)(Searcher *, int, float, void *);
 };
 
-void msea_search_each_i(Searcher *self, int doc_num, float score, void *arg)
+static void msea_search_each_i(Searcher *self, int doc_num, float score, void *arg)
 {
     struct MultiSearchEachArg *mse_arg = (struct MultiSearchEachArg *)arg;
 
@@ -1491,7 +1560,7 @@ void msea_search_each_i(Searcher *self, int doc_num, float score, void *arg)
 }
 
 static void msea_search_each_w(Searcher *self, Weight *w, Filter *filter,
-                               filter_ft filter_func,
+                               PostFilter *post_filter,
                                void (*fn)(Searcher *, int, float, void *),
                                void *arg)
 {
@@ -1505,18 +1574,68 @@ static void msea_search_each_w(Searcher *self, Weight *w, Filter *filter,
     for (i = 0; i < msea->s_cnt; i++) {
         s = msea->searchers[i];
         mse_arg.start = msea->starts[i];
-        s->search_each_w(s, w, filter, filter_func,
+        s->search_each_w(s, w, filter, post_filter,
                          &msea_search_each_i, &mse_arg);
     }
 }
 
 static void msea_search_each(Searcher *self, Query *query, Filter *filter,
-                             filter_ft filter_func,
-                             void (*fn)(Searcher *, int, float, void *), void *arg)
+                             PostFilter *post_filter,
+                             void (*fn)(Searcher *, int, float, void *),
+                             void *arg)
 {
-    Weight *w = q_weight(query, self);
-    msea_search_each_w(self, w, filter, filter_func, fn, arg);
-    w->destroy(w);
+    Weight *weight = q_weight(query, self);
+    msea_search_each_w(self, weight, filter, post_filter, fn, arg);
+    weight->destroy(weight);
+}
+
+static int msea_search_unscored_w(Searcher *self,
+                                  Weight *w,
+                                  int *buf,
+                                  int limit,
+                                  int offset_docnum)
+{
+    int i, count = 0;
+    MultiSearcher *msea = MSEA(self);
+
+    for (i = 0; count < limit && i < msea->s_cnt; i++) {
+        /* if offset_docnum falls in this or previous indexes */
+        if (offset_docnum < msea->starts[i+1]) {
+            Searcher *searcher = msea->searchers[i];
+            const int index_offset = msea->starts[i];
+            int current_limit = limit - count;
+            /* if offset_docnum occurs in the current index then adjust,
+             * otherwise set it to zero as it occured in a previous index */
+            int current_offset_docnum = offset_docnum > index_offset
+                ? offset_docnum - index_offset
+                : 0;
+
+            /* record current count as we'll need to update docnums by the
+             * index's offset */
+            int j = count;
+            count += searcher->search_unscored_w(searcher, w, buf + count,
+                                                 current_limit,
+                                                 current_offset_docnum);
+            /* update doc nums with the current index's offsets */
+            for (; j < count; j++) {
+                buf[j] += index_offset;
+            }
+        }
+    }
+    return count;
+}
+
+static int msea_search_unscored(Searcher *self,
+                                Query *query,
+                                int *buf,
+                                int limit,
+                                int offset_docnum)
+{
+    int count;
+    Weight *weight = q_weight(query, self);
+    count = msea_search_unscored_w(self, weight, buf, limit, offset_docnum);
+    weight->destroy(weight);
+    return count;
 }
 
 struct MultiSearchArg {
@@ -1525,7 +1644,9 @@ struct MultiSearchArg {
     void (*hq_insert)(PriorityQueue *pq, Hit *hit);
 };
 
-void msea_search_i(Searcher *self, int doc_num, float score, void *arg)
+/*
+ * FIXME Not used anywhere. Is it needed?
+static void msea_search_i(Searcher *self, int doc_num, float score, void *arg)
 {
     struct MultiSearchArg *ms_arg = (struct MultiSearchArg *)arg;
     Hit hit;
@@ -1536,6 +1657,7 @@ void msea_search_i(Searcher *self, int doc_num, float score, void *arg)
     hit.score = score;
     ms_arg->hq_insert(ms_arg->hq, &hit);
 }
+*/
 
 static TopDocs *msea_search_w(Searcher *self,
                               Weight *weight,
@@ -1543,7 +1665,7 @@ static TopDocs *msea_search_w(Searcher *self,
                               int num_docs,
                               Filter *filter,
                               Sort *sort,
-                              filter_ft filter_func,
+                              PostFilter *post_filter,
                               bool load_fields)
 {
     int max_size = num_docs + (num_docs == INT_MAX ? 0 : first_doc);
@@ -1573,7 +1695,7 @@ static TopDocs *msea_search_w(Searcher *self,
     for (i = 0; i < MSEA(self)->s_cnt; i++) {
         Searcher *s = MSEA(self)->searchers[i];
         TopDocs *td = s->search_w(s, weight, 0, max_size,
-                                  filter, sort, filter_func, true);
+                                  filter, sort, post_filter, true);
         /*if (sort) printf("sort = %s\n", sort_to_s(sort)); */
         if (td->size > 0) {
             /*printf("td->size = %d %d\n", td->size, num_docs); */
@@ -1622,13 +1744,13 @@ static TopDocs *msea_search(Searcher *self,
                             int num_docs,
                             Filter *filter,
                             Sort *sort,
-                            filter_ft filter_func,
+                            PostFilter *post_filter,
                             bool load_fields)
 {
     TopDocs *td;
     Weight *weight = q_weight(query, self);
     td = msea_search_w(self, weight, first_doc, num_docs, filter,
-                       sort, filter_func, load_fields);
+                       sort, post_filter, load_fields);
     weight->destroy(weight);
     return td;
 }
@@ -1674,13 +1796,12 @@ static Explanation *msea_explain_w(Searcher *self, Weight *w, int doc_num)
 }
 
 static TermVector *msea_get_term_vector(Searcher *self, const int doc_num,
-                                        const char *field)
+                                        Symbol field)
 {
     MultiSearcher *msea = MSEA(self);
     int i = msea_get_searcher_index(self, doc_num);
     Searcher *s = msea->searchers[i];
-    return s->get_term_vector(s, doc_num - msea->starts[i],
-                              field);
+    return s->get_term_vector(s, doc_num - msea->starts[i], field);
 }
 
 static Similarity *msea_get_similarity(Searcher *self)
@@ -1707,7 +1828,7 @@ static void msea_close(Searcher *self)
 Searcher *msea_new(Searcher **searchers, int s_cnt, bool close_subs)
 {
     int i, max_doc = 0;
-    Searcher *self = (Searcher *)ecalloc(sizeof(MultiSearcher));
+    Searcher *self = (Searcher *)ALLOC(MultiSearcher);
     int *starts = ALLOC_N(int, s_cnt + 1);
     for (i = 0; i < s_cnt; i++) {
         starts[i] = max_doc;
@@ -1731,6 +1852,8 @@ Searcher *msea_new(Searcher **searchers, int s_cnt, bool close_subs)
     self->search_w              = &msea_search_w;
     self->search_each           = &msea_search_each;
     self->search_each_w         = &msea_search_each_w;
+    self->search_unscored       = &msea_search_unscored;
+    self->search_unscored_w     = &msea_search_unscored_w;
     self->rewrite               = &msea_rewrite;
     self->explain               = &msea_explain;
     self->explain_w             = &msea_explain_w;