ferret 0.9.1 → 0.9.2

data/ext/q_const_score.c

@@ -12,11 +12,6 @@ char *csw_to_s(Weight *self)
   return strfmt("ConstantScoreWeight(%f)", self->value);
 }
 
-void csw_destroy(void *p)
-{
-  free(p);
-}
-
 Explanation *csw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
   Filter *filter = (Filter *)self->query->data;
@@ -40,21 +35,14 @@ Explanation *csw_explain(Weight *self, IndexReader *ir, int doc_num)
 
 Weight *csw_create(Query *query, Searcher *searcher)
 {
-  Weight *self = ALLOC(Weight);
-  ZEROSET(self, Weight, 1);
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
-  self->normalize = &w_normalize;
+  Weight *self = w_create(query);
   self->scorer    = &cssc_create;
   self->explain   = &csw_explain;
   self->to_s      = &csw_to_s;
-  self->destroy   = &csw_destroy;
   self->sum_of_squared_weights = &w_sum_of_squared_weights;
 
   self->similarity = query->get_similarity(query, searcher);
   self->idf = 1.0;
-  self->query = query;
-  self->value = 0.0;
 
   return self;
 }
@@ -79,24 +67,36 @@ char *csq_to_s(Query *self, char *field)
   return buffer;;
 }
 
-void csq_destroy(void *p)
+void csq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   if (self->destroy_all) {
     Filter *filter = (Filter *)self->data;
     filter->destroy(filter);
   }
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint csq_hash(Query *self)
+{
+  return filt_hash((Filter *)self->data);
+}
+
+static int csq_eq(Query *self, Query *o)
+{
+  return filt_eq((Filter *)self->data, (Filter *)o->data);
 }
 
 Query *csq_create(Filter *filter)
 {
   Query *self = q_create();
-  self->type = CONSTANT_QUERY;
   self->data = filter;
-  self->create_weight = &csw_create;
+
+  self->type = CONSTANT_QUERY;
   self->to_s = &csq_to_s;
-  self->destroy = &csq_destroy;
+  self->hash = &csq_hash;
+  self->eq = &csq_eq;
+  self->destroy_i = &csq_destroy;
+  self->create_weight_i = &csw_create;
 
   return self;
 }
@@ -143,6 +143,6 @@ Scorer *cssc_create(Weight *weight, IndexReader *ir)
   self->next = &cssc_next;
   self->skip_to = &cssc_skip_to;
   self->explain = &cssc_explain;
-  self->destroy = &scorer_destroy;
+  self->destroy = &scorer_destroy_i;
   return self;
 }

data/ext/q_filtered_query.c

@@ -14,11 +14,6 @@ char *fqw_to_s(Weight *self)
   return strfmt("FilteredQueryWeight(%f)", self->value);
 }
 
-void fqw_destroy(void *p)
-{
-  free(p);
-}
-
 float fqw_sum_of_squared_weights(Weight *self)
 {
   Weight *sw = (Weight *)self->data;
@@ -28,7 +23,7 @@ float fqw_sum_of_squared_weights(Weight *self)
 void fqw_normalize(Weight *self, float normalization_factor)
 {
   Weight *sw = (Weight *)self->data;
-  return sw->normalize(sw, normalization_factor);
+  sw->normalize(sw, normalization_factor);
 }
 
 float fqw_get_value(Weight *self)
@@ -52,13 +47,19 @@ Scorer *fqw_scorer(Weight *self, IndexReader *ir)
   return fqsc_create(scorer, filter->get_bv(filter, ir), self->similarity);
 }
 
+void fqw_destroy(Weight *self)
+{
+  Weight *sw = (Weight *)self->data;
+  sw->destroy(sw);
+  w_destroy(self);
+}
+
 Weight *fqw_create(Query *query, Weight *sub_weight, Similarity *sim)
 {
-  Weight *self = ALLOC(Weight);
-  ZEROSET(self, Weight, 1);
+  Weight *self = w_create(query);
+
   self->data = sub_weight;
 
-  self->get_query = &w_get_query;
   self->get_value = &fqw_get_value;
   self->normalize = &fqw_normalize;
   self->scorer    = &fqw_scorer;
@@ -69,7 +70,6 @@ Weight *fqw_create(Query *query, Weight *sub_weight, Similarity *sim)
 
   self->similarity = sim;
   self->idf = 1.0;
-  self->query = query;
   self->value = sub_weight->value;
 
   return self;
@@ -99,16 +99,15 @@ char *fq_to_s(Query *self, char *field)
   return buffer;;
 }
 
-void fq_destroy(void *p)
+void fq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   if (self->destroy_all) {
     FilteredQuery *fq = (FilteredQuery *)self->data;
     fq->filter->destroy(fq->filter);
-    fq->query->destroy(fq->query);
+    q_deref(fq->query);
   }
   free(self->data);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
 Weight *fq_create_weight(Query *self, Searcher *searcher)
@@ -121,14 +120,16 @@ Weight *fq_create_weight(Query *self, Searcher *searcher)
 Query *fq_create(Query *query, Filter *filter)
 {
   Query *self = q_create();
+
   FilteredQuery *fq = ALLOC(FilteredQuery);
   fq->query = query;
   fq->filter = filter;
-  self->type = FILTERED_QUERY;
   self->data = fq;
-  self->create_weight = &fq_create_weight;
+
+  self->type = FILTERED_QUERY;
   self->to_s = &fq_to_s;
-  self->destroy = &fq_destroy;
+  self->destroy_i = &fq_destroy;
+  self->create_weight_i = &fq_create_weight;
 
   return self;
 }
@@ -180,13 +181,12 @@ Explanation *fqsc_explain(Scorer *self, int doc_num)
   return sub_sc->explain(sub_sc, doc_num);
 }
 
-void fqsc_destroy(void *p)
+void fqsc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   FilteredQueryScorer *fqsc = (FilteredQueryScorer *)self->data;
   bv_destroy(fqsc->bv);
   fqsc->sub_scorer->destroy(fqsc->sub_scorer);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *fqsc_create(Scorer *scorer, BitVector *bv, Similarity *sim)

data/ext/q_fuzzy.c

@@ -24,7 +24,7 @@ void fuzq_initialize_max_distances(FuzzyQuery *fuzq)
   }
 }
 
-float fuzq_get_max_distance(FuzzyQuery *fuzq, int m)
+int fuzq_get_max_distance(FuzzyQuery *fuzq, int m)
 {
   return (m < TYPICAL_LONGEST_WORD) ? fuzq->max_distances[m]
                                     : fuzq_calculate_max_distance(fuzq, m);
@@ -34,7 +34,7 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
 {
   int i, j;
   int max_distance;
-  int m = strlen(target);
+  int m = (int)strlen(target);
   int n = fuzq->text_len;
   int *d = fuzq->da;
   char *text = fuzq->text;
@@ -82,7 +82,7 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
       } else {
         d[i + m*j] = min3(d[i-1 + m*j]+1, d[i + m*(j-1)]+1, d[i-1 + m*(j-1)]);
       }
-      best_pos_ed_dist = min(best_pos_ed_dist, d[i + m*j]);
+      best_pos_ed_dist = min2(best_pos_ed_dist, d[i + m*j]);
     }
     //printf("(bped = %d, i = %d, md = %d)", best_pos_ed_dist, i, max_distance);
 
@@ -104,7 +104,7 @@ float fuzq_score(FuzzyQuery *fuzq, char *target)
    * number of characters in the shorter word.  but this was the formula that
    * was previously used in FuzzyTermEnum, so it has not been changed (even
    * though min_sim must be greater than 0.0) */
-  return 1.0f - ((float)d[n + m*m] / (float) (fuzq->pre_len + min(n, m)));
+  return 1.0f - ((float)d[n + m*m] / (float) (fuzq->pre_len + min2(n, m)));
 }
 
 /****************************************************************************
@@ -118,8 +118,8 @@ char *fuzq_to_s(Query *self, char *field)
   char *buffer, *bptr;
   FuzzyQuery *fuzq = (FuzzyQuery *)self->data;
   Term *term = fuzq->term;
-  int tlen = strlen(term->text);
-  int flen = strlen(term->field);
+  int tlen = (int)strlen(term->text);
+  int flen = (int)strlen(term->field);
   bptr = buffer = ALLOC_N(char, tlen + flen + 35);
 
   if (strcmp(term->field, field) != 0) {
@@ -155,11 +155,10 @@ bool scored_term_less_than(void *p1, void *p2)
   return (st1->score < st2->score);
 }
 
-void scored_term_destroy(void *p)
+void scored_term_destroy(ScoredTerm *self)
 {
-  ScoredTerm *st = (ScoredTerm *)p;
-  term_destroy(st->term);
-  free(st);
+  term_destroy(self->term);
+  free(self);
 }
 
 ScoredTerm *scored_term_create(Term *term, float score)
@@ -181,7 +180,7 @@ Query *fuzq_rewrite(Query *self, IndexReader *ir)
   char *field = term->field;
   Term prefix_term;
   prefix_term.field = field;
-  if (fuzq->pre_len >= strlen(text)) {
+  if (fuzq->pre_len >= (int)strlen(text)) {
     q = tq_create(term_clone(term));
   } else {
     PriorityQueue *term_pq;
@@ -195,7 +194,7 @@ Query *fuzq_rewrite(Query *self, IndexReader *ir)
 
     term_pq = pq_create(((BooleanQuery *)q->data)->max_clause_cnt,
         &scored_term_less_than);
-    term_pq->free_elem = &scored_term_destroy;
+    term_pq->free_elem = (free_ft)&scored_term_destroy;
 
     prefix_term.field = field;
     prefix_term.text = (char *)EMPTY_STRING;
@@ -207,9 +206,9 @@ Query *fuzq_rewrite(Query *self, IndexReader *ir)
     }
     te = ir->terms_from(ir, &prefix_term);
 
-    fuzq->scale_factor = 1.0 / (1.0 - fuzq->min_sim);
+    fuzq->scale_factor = (float)(1.0 / (1.0 - fuzq->min_sim));
     fuzq->text = fuzq->term->text + pre_len;
-    fuzq->text_len = strlen(fuzq->text);
+    fuzq->text_len = (int)strlen(fuzq->text);
     fuzq_initialize_max_distances(fuzq);
 
     if (te) {
@@ -246,36 +245,51 @@ Query *fuzq_rewrite(Query *self, IndexReader *ir)
     pq_destroy(term_pq);
   }
 
-  if (self->rewritten) self->rewritten->destroy(self->rewritten);
-  return self->rewritten = q;
+  return q;
 }
 
-void fuzq_destroy(void *p)
+void fuzq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   FuzzyQuery *fuzq = (FuzzyQuery *)self->data;
   if (self->destroy_all) term_destroy((Term *)fuzq->term);
   free(fuzq->da);
   free(fuzq);
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint fuzq_hash(Query *self)
+{
+  FuzzyQuery *fq = (FuzzyQuery *)self->data;
+  return term_hash(fq->term) ^ *((int *)&fq->min_sim) ^ fq->pre_len;
+}
+
+static int fuzq_eq(Query *self, Query *o)
+{
+  FuzzyQuery *fq1 = (FuzzyQuery *)self->data;
+  FuzzyQuery *fq2 = (FuzzyQuery *)o->data;
+  return term_eq(fq1->term, fq2->term) &&
+    (fq1->pre_len == fq2->pre_len) && 
+    (fq1->min_sim == fq2->min_sim);
 }
 
 Query *fuzq_create(Term *term)
 {
   Query *self = q_create();
+
   FuzzyQuery *fq = ALLOC(FuzzyQuery);
   ZEROSET(fq, FuzzyQuery, 1);
-
   fq->term = term;
   fq->pre_len = DEF_PRE_LEN;
   fq->min_sim = DEF_MIN_SIM;
   self->data = fq;
+
   self->type = FUZZY_QUERY;
-  self->create_weight = NULL;
   self->to_s = &fuzq_to_s;
+  self->hash = &fuzq_hash;
+  self->eq = &fuzq_eq;
   self->rewrite = &fuzq_rewrite;
-  self->destroy = &fuzq_destroy;
-  self->rewritten = NULL;
+  self->destroy_i = &fuzq_destroy;
+  self->create_weight_i = &q_create_weight_unsup;
 
   return self;
 }

data/ext/q_match_all.c

@@ -12,11 +12,6 @@ char *maw_to_s(Weight *self)
   return strfmt("MatchAllWeight(%f)", self->value);
 }
 
-void maw_destroy(void *p)
-{
-  free(p);
-}
-
 Explanation *maw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
   Explanation *expl;
@@ -34,21 +29,15 @@ Explanation *maw_explain(Weight *self, IndexReader *ir, int doc_num)
 
 Weight *maw_create(Query *query, Searcher *searcher)
 {
-  Weight *self = ALLOC(Weight);
-  ZEROSET(self, Weight, 1);
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
-  self->normalize = &w_normalize;
+  Weight *self = w_create(query);
+
   self->scorer    = &masc_create;
   self->explain   = &maw_explain;
   self->to_s      = &maw_to_s;
-  self->destroy   = &maw_destroy;
   self->sum_of_squared_weights = &w_sum_of_squared_weights;
 
   self->similarity = query->get_similarity(query, searcher);
   self->idf = 1.0;
-  self->query = query;
-  self->value = 0.0;
 
   return self;
 }
@@ -68,19 +57,26 @@ char *maq_to_s(Query *self, char *field)
   }
 }
 
-void maq_destroy(void *p)
+static uint maq_hash(Query *self)
 {
-  Query *self = (Query *)p;
-  q_destroy(self);
+  return 0;
+}
+
+static int maq_eq(Query *self, Query *o)
+{
+  return true;
 }
 
 Query *maq_create()
 {
   Query *self = q_create();
+
   self->type = MATCH_ALL_QUERY;
-  self->create_weight = &maw_create;
   self->to_s = &maq_to_s;
-  self->destroy = &maq_destroy;
+  self->hash = &maq_hash;
+  self->eq = &maq_eq;
+  self->destroy_i = &q_destroy_i;
+  self->create_weight_i = &maw_create;
 
   return self;
 }
@@ -133,6 +129,6 @@ Scorer *masc_create(Weight *weight, IndexReader *ir)
   self->next = &masc_next;
   self->skip_to = &masc_skip_to;
   self->explain = &masc_explain;
-  self->destroy = &scorer_destroy;
+  self->destroy = &scorer_destroy_i;
   return self;
 }

data/ext/q_multi_phrase.c

@@ -1,5 +1,5 @@
-#include <string.h>
 #include "search.h"
+#include <string.h>
 
 static char * const FIELD_CHANGE_ERROR_MSG = "All phrase terms must be in the same field.";
 
@@ -19,9 +19,13 @@ Scorer *mphw_scorer(Weight *self, IndexReader *ir)
   Scorer *phsc;
   MultiPhraseQuery *mphq = (MultiPhraseQuery *)self->query->data;
   int i;
-  if (mphq->t_cnt == 0) return NULL; // optimize zero-term case
+  TermDocEnum **tps;
+
+  if (mphq->t_cnt == 0) {
+    return NULL; /* optimize zero-term case */
+  }
 
-  TermDocEnum **tps = ALLOC_N(TermDocEnum *, mphq->t_cnt);
+  tps = ALLOC_N(TermDocEnum *, mphq->t_cnt);
 
   for (i = 0; i < mphq->t_cnt; i++) {
     if (mphq->pt_cnt[i] == 1) {
@@ -56,6 +60,17 @@ Scorer *mphw_scorer(Weight *self, IndexReader *ir)
 
 Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
+  Explanation *idf_expl1;
+  Explanation *idf_expl2;
+  Explanation *query_expl;
+  Explanation *qnorm_expl;
+  Explanation *field_expl;
+  Explanation *tf_expl;
+  Scorer *scorer;
+  uchar *field_norms;
+  float field_norm;
+  Explanation *field_norm_expl;
+
   char *query_str = self->query->to_s(self->query, "");
   MultiPhraseQuery *mphq = (MultiPhraseQuery *)self->query->data;
   int i, j;
@@ -67,7 +82,7 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
 
   for (i = 0; i < mphq->t_cnt; i++) {
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
-      len += strlen(mphq->terms[i][j]->text) + 30;
+      len += (int)strlen(mphq->terms[i][j]->text) + 30;
     }
   }
   doc_freqs = ALLOC_N(char, len);
@@ -75,20 +90,20 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
       Term *term = mphq->terms[i][j];
       sprintf(doc_freqs + pos, "%s=%d, ", term->text, ir->doc_freq(ir, term));
-      pos += strlen(doc_freqs + pos);
+      pos += (int)strlen(doc_freqs + pos);
     }
   }
   pos -= 2; // remove ", " from the end
   doc_freqs[pos] = 0;
 
-  Explanation *idf_expl1 = expl_create(self->idf,
+  idf_expl1 = expl_create(self->idf,
       strfmt("idf(%s:<%s>)", mphq->field, doc_freqs));
-  Explanation *idf_expl2 = expl_create(self->idf,
+  idf_expl2 = expl_create(self->idf,
       strfmt("idf(%s:<%s>)", mphq->field, doc_freqs));
   free(doc_freqs);
   
-  // explain query weight
-  Explanation *query_expl = expl_create(0.0, 
+  /* explain query weight */
+  query_expl = expl_create(0.0, 
       strfmt("query_weight(%s), product of:", query_str));
 
   if (self->query->boost != 1.0) {
@@ -96,36 +111,36 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
   }
   expl_add_detail(query_expl, idf_expl1);
   
-  Explanation *qnorm_expl = expl_create(self->qnorm, estrdup("query_norm"));
+  qnorm_expl = expl_create(self->qnorm, estrdup("query_norm"));
   expl_add_detail(query_expl, qnorm_expl);
   
   query_expl->value = self->query->boost * self->idf * self->qnorm;
 
   expl_add_detail(expl, query_expl);
  
-  // explain field weight
-  Explanation *field_expl = expl_create(0.0, 
+  /* explain field weight */
+  field_expl = expl_create(0.0, 
       strfmt("field_weight(%s in %d), product of:", query_str, doc_num));
   free(query_str);
 
-  Scorer *scorer = self->scorer(self, ir);
-  Explanation *tf_expl = scorer->explain(scorer, doc_num);
+  scorer = self->scorer(self, ir);
+  tf_expl = scorer->explain(scorer, doc_num);
   scorer->destroy(scorer);
   expl_add_detail(field_expl, tf_expl);
   expl_add_detail(field_expl, idf_expl2);
 
-  uchar *field_norms = ir->get_norms(ir, mphq->field);
-  float field_norm = (field_norms != NULL)
+  field_norms = ir->get_norms(ir, mphq->field);
+  field_norm = (field_norms != NULL)
     ? sim_decode_norm(self->similarity, field_norms[doc_num])
-    : 0.0;
-  Explanation *field_norm_expl = expl_create(field_norm,
+    : (float)0.0;
+  field_norm_expl = expl_create(field_norm,
     strfmt("field_norm(field=%s, doc=%d)", mphq->field, doc_num));
 
   expl_add_detail(field_expl, field_norm_expl);
 
   field_expl->value = tf_expl->value * self->idf * field_norm;
   
-  // combine them
+  /* combine them */
   if (query_expl->value == 1.0) {
     expl_destoy(expl);
     return field_expl;
@@ -136,29 +151,23 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
   }
 }
 
-
-
-
 Weight *mphw_create(Query *query, Searcher *searcher)
 {
+  Weight *self = w_create(query);
+
   MultiPhraseQuery *mphq = (MultiPhraseQuery *)query->data;
-  Weight *self = ALLOC(Weight);
   int i, j;
-  ZEROSET(self, Weight, 1);
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
-  self->normalize = &w_normalize;
+
   self->scorer    = &mphw_scorer;
   self->explain   = &mphw_explain;
   self->to_s      = &mphw_to_s;
-  self->destroy   = &free;
   self->sum_of_squared_weights = &w_sum_of_squared_weights;
 
   self->similarity = query->get_similarity(query, searcher);
   self->query = query;
   self->value = query->boost;
-
   self->idf = 0.0;
+
   for (i = 0; i < mphq->t_cnt; i++) {
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
       self->idf += sim_idf_term(self->similarity, mphq->terms[i][j], searcher);
@@ -209,10 +218,8 @@ void mphq_add_terms(Query *self, Term **terms, int t_cnt, int pos_inc)
   mphq->t_cnt++;
 }
 
-void mphq_destroy(void *p)
+void mphq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
-
   GET_MPHQ;
   int i, j;
   if (self->destroy_all) {
@@ -228,16 +235,16 @@ void mphq_destroy(void *p)
   free(mphq->pt_cnt);
   free(mphq);
 
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
-void mphq_extract_terms(Query *self, Array *terms)
+void mphq_extract_terms(Query *self, HashSet *terms)
 {
   GET_MPHQ;
   int i, j;
   for (i = 0; i < mphq->t_cnt; i++) {
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
-      ary_append(terms, mphq->terms[i][j]);
+      hs_add(terms, term_clone(mphq->terms[i][j]));
     }
   }
 }
@@ -248,10 +255,10 @@ char *mphq_to_s(Query *self, char *field)
   int i, j, buf_index = 0, len = 0, pos, last_pos = -1;
   char *buffer;
   if (!mphq->t_cnt) return NULL;
-  len = strlen(mphq->field) + 1;
+  len = (int)strlen(mphq->field) + 1;
   for (i = 0; i < mphq->t_cnt; i++) {
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
-      len += strlen(mphq->terms[i][j]->text) + 1;
+      len += (int)strlen(mphq->terms[i][j]->text) + 1;
     }
   }
 
@@ -261,7 +268,7 @@ char *mphq_to_s(Query *self, char *field)
   buffer = ALLOC_N(char, len);
 
   if (strcmp(field, mphq->field) != 0) {
-    len = strlen(mphq->field);
+    len = (int)strlen(mphq->field);
     memcpy(buffer, mphq->field, len);
     buffer[len] = ':';
     buf_index += len + 1;
@@ -278,7 +285,7 @@ char *mphq_to_s(Query *self, char *field)
 
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
       Term *term = mphq->terms[i][j];
-      len = strlen(term->text);
+      len = (int)strlen(term->text);
       memcpy(buffer + buf_index, term->text, len);
       buf_index += len;
       buffer[buf_index++] = '|';
@@ -291,7 +298,7 @@ char *mphq_to_s(Query *self, char *field)
   buffer[buf_index] = 0;
   if (mphq->slop != 0) {
     sprintf(buffer + buf_index, "~%d", mphq->slop);
-    buf_index += strlen(buffer + buf_index);
+    buf_index += (int)strlen(buffer + buf_index);
   }
   if (self->boost != 1.0) {
     buffer[buf_index] = '^';
@@ -311,16 +318,48 @@ Query *mphq_rewrite(Query *self, IndexReader *ir)
       bq_add_query(bq, tq_create(term_clone(terms[i])), BC_SHOULD);
     }
     bq->boost = self->boost;
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = bq;
+    return bq;
   } else {
+    self->ref_cnt++;
     return self;
   }
 }
     
+static uint mphq_hash(Query *self)
+{
+  int i, j;
+  uint hash = 0;
+  MultiPhraseQuery *mphq = (MultiPhraseQuery *)self->data;
+  for (i = 0; i < mphq->t_cnt; i++) {
+    for (j = 0; j < mphq->pt_cnt[i]; j++) {
+      hash ^= (term_hash(mphq->terms[i][j]) ^ mphq->positions[i]);
+    }
+    hash <<= 1;
+  }
+  return (hash ^ mphq->slop);
+}
+
+static int mphq_eq(Query *self, Query *o)
+{
+  int i, j;
+  MultiPhraseQuery *mphq1 = (MultiPhraseQuery *)self->data;
+  MultiPhraseQuery *mphq2 = (MultiPhraseQuery *)o->data;
+  if (mphq1->slop != mphq2->slop) return false;
+  for (i = 0; i < mphq1->t_cnt; i++) {
+    if ((mphq1->pt_cnt[i] != mphq2->pt_cnt[i]) ||
+        (mphq1->positions[i] != mphq2->positions[i])) return false;
+
+    for (j = 0; j < mphq1->pt_cnt[i]; j++) {
+      if (!term_eq(mphq1->terms[i][j], mphq2->terms[i][j])) return false;
+    }
+  }
+  return true;
+}
+
 Query *mphq_create()
 {
   Query *self = q_create();
+
   MultiPhraseQuery *mphq = ALLOC(MultiPhraseQuery);
   ZEROSET(mphq, MultiPhraseQuery, 1);
   mphq->t_capa = PHQ_INIT_CAPA;
@@ -329,11 +368,13 @@ Query *mphq_create()
   mphq->pt_cnt = ALLOC_N(int, PHQ_INIT_CAPA);
   self->data = mphq;
 
-  self->create_weight = &mphw_create;
+  self->type = MULTI_PHRASE_QUERY;
+  self->rewrite = &mphq_rewrite;
   self->extract_terms = &mphq_extract_terms;
   self->to_s = &mphq_to_s;
-  self->destroy = &mphq_destroy;
-  self->rewrite = &mphq_rewrite;
-  self->type = PHRASE_QUERY;
+  self->hash = &mphq_hash;
+  self->eq = &mphq_eq;
+  self->destroy_i = &mphq_destroy;
+  self->create_weight_i = &mphw_create;
   return self;
 }