ferret 0.9.1 → 0.9.2

data/ext/q_span.c

@@ -1,7 +1,6 @@
 #include <string.h>
 #include "search.h"
 
-
 /*****************************************************************************
  *
  * NearSpanEnum
@@ -16,11 +15,24 @@
 
 Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
 {
+  Explanation *expl;
+  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, "");
-  Array *terms = (Array *)self->data;
+  HashSet *terms = (HashSet *)self->data;
   char *field = ((SpanQuery *)self->query->data)->field;
   char *doc_freqs = NULL;
-  int df_i = 0, i;
+  size_t df_i = 0;
+  int i;
   Term *t;
 
 
@@ -38,19 +50,21 @@ Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
     doc_freqs = "";
   }
 
-  Explanation *expl = expl_create(0.0,
+  expl = expl_create(0.0,
       strfmt("weight(%s in %d), product of:", query_str, target));
 
   /* We need two of these as it's included in both the query explanation
    * and the field explanation */
-  Explanation *idf_expl1 = expl_create(self->idf,
+  idf_expl1 = expl_create(self->idf,
       strfmt("idf(%s: %s)", field, doc_freqs));
-  Explanation *idf_expl2 = expl_create(self->idf,
+  idf_expl2 = expl_create(self->idf,
       strfmt("idf(%s: %s)", field, doc_freqs));
-  if (terms->size > 0) free(doc_freqs); /* only free if allocated */
+  if (terms->size > 0) {
+    free(doc_freqs); /* only free if allocated */
+  }
 
   /* explain query weight */
-  Explanation *query_expl = expl_create(0.0,
+  query_expl = expl_create(0.0,
       strfmt("query_weight(%s), product of:", query_str));
 
   if (self->query->boost != 1.0) {
@@ -59,7 +73,7 @@ Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
 
   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 * idf_expl1->value * qnorm_expl->value;
@@ -67,19 +81,21 @@ Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
   expl_add_detail(expl, query_expl);
 
   /* explain field weight */
-  Explanation *field_expl = expl_create(0.0, 
+  field_expl = expl_create(0.0, 
       strfmt("field_weight(%s:%s in %d), product of:", field, query_str, target));
   free(query_str);
 
-  Scorer *scorer = self->scorer(self, ir);
-  Explanation *tf_expl = scorer->explain(scorer, target);
+  scorer = self->scorer(self, ir);
+  tf_expl = scorer->explain(scorer, target);
   scorer->destroy(scorer);
   expl_add_detail(field_expl, tf_expl);
   expl_add_detail(field_expl, idf_expl2);
 
-  uchar *field_norms = ir->get_norms(ir, field);
-  float field_norm = (field_norms ? sim_decode_norm(self->similarity, field_norms[target]) : 0.0);
-  Explanation *field_norm_expl = expl_create(field_norm,
+  field_norms = ir->get_norms(ir, field);
+  field_norm = (field_norms 
+    ? sim_decode_norm(self->similarity, field_norms[target]) 
+    : (float)0.0);
+  field_norm_expl = expl_create(field_norm,
       strfmt("field_norm(field=%s, doc=%d)", field, target));
   expl_add_detail(field_expl, field_norm_expl);
 
@@ -101,22 +117,19 @@ char *spanw_to_s(Weight *self)
   return strfmt("SpanWeight(%f)", self->value);
 }
 
-void spanw_destroy(void *p)
+void spanw_destroy(Weight *self)
 {
-  Weight *self = (Weight *)p;
-  ary_destroy(self->data);
-  free(p);
+  hs_destroy_all(self->data);
+  w_destroy(self);
 }
 
 Weight *spanw_create(Query *query, Searcher *searcher)
 {
-  Weight *self = ALLOC(Weight);
+  Weight *self = w_create(query);
   SpanQuery *spanq = (SpanQuery *)query->data;
-  Array *terms = spanq->get_terms(query);
-  ZEROSET(self, Weight, 1);
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
-  self->normalize = &w_normalize;
+  HashSet *terms = spanq->get_terms(query);
+
+  self->data = terms;
   self->scorer    = &spansc_create;
   self->explain   = &spanw_explain;
   self->to_s      = &spanw_to_s;
@@ -125,10 +138,8 @@ Weight *spanw_create(Query *query, Searcher *searcher)
 
   self->similarity = query->get_similarity(query, searcher);
 
-  self->idf = sim_idf_phrase(self->similarity, (Term **)terms->elems, terms->size, searcher);
-  self->query = query;
-  self->value = 0.0;
-  self->data = terms;
+  self->idf = sim_idf_phrase(self->similarity, (Term **)terms->elems,
+      terms->size, searcher);
 
   return self;
 }
@@ -204,7 +215,8 @@ char *spante_to_s(SpanEnum *self)
   char *field = ((SpanQuery *)self->query->data)->field;
   char *query_str = self->query->to_s(self->query, field);
   char pos_str[20];
-  int len = strlen(query_str), pos;
+  size_t len = strlen(query_str);
+  int pos;
   char *str = ALLOC_N(char, len + 40);
 
   if (self->doc(self) < 0) {
@@ -222,9 +234,8 @@ char *spante_to_s(SpanEnum *self)
   return str;
 }
 
-void spante_destroy(void *p)
+void spante_destroy(SpanEnum *self)
 {
-  SpanEnum *self = (SpanEnum *)p;
   SpanTermEnum *ste = (SpanTermEnum *)self->data;
   TermDocEnum *tde = ste->positions;
   tde->close(tde);
@@ -315,9 +326,8 @@ char *spanfe_to_s(SpanEnum *self)
   return res;
 }
 
-void spanfe_destroy(void *p)
+void spanfe_destroy(SpanEnum *self)
 {
-  SpanEnum *self = (SpanEnum *)p;
   SpanEnum *se = (SpanEnum *)self->data;
   se->destroy(se);
   free(self);
@@ -449,7 +459,7 @@ char *spanoe_to_s(SpanEnum *self)
   char *field = ((SpanQuery *)self->query->data)->field;
   char *query_str = self->query->to_s(self->query, field);
   char doc_str[62];
-  int len = strlen(query_str);
+  size_t len = strlen(query_str);
   char *str = ALLOC_N(char, len + 80);
 
   if (soe->first_time) {
@@ -467,9 +477,9 @@ char *spanoe_to_s(SpanEnum *self)
   return str;
 }
 
-void spanoe_destroy(void *p)
+void spanoe_destroy(SpanEnum *self)
 {
-  SpanEnum *self = (SpanEnum *)p, *se;
+  SpanEnum *se;
   SpanOrEnum *soe = (SpanOrEnum *)self->data;
   int i;
   pq_destroy(soe->queue);
@@ -730,7 +740,7 @@ char *spanne_to_s(SpanEnum *self)
   char *field = ((SpanQuery *)self->query->data)->field;
   char *query_str = self->query->to_s(self->query, field);
   char doc_str[62];
-  int len = strlen(query_str);
+  size_t len = strlen(query_str);
   char *str = ALLOC_N(char, len + 80);
 
   if (sne->first_time) {
@@ -744,9 +754,9 @@ char *spanne_to_s(SpanEnum *self)
   return str;
 }
 
-void spanne_destroy(void *p)
+void spanne_destroy(SpanEnum *self)
 {
-  SpanEnum *self = (SpanEnum *)p, *se;
+  SpanEnum *se;
   SpanNearEnum *sne = (SpanNearEnum *)self->data;
   int i;
   for (i = 0; i < sne->s_cnt; i++) {
@@ -886,9 +896,8 @@ char *spanxe_to_s(SpanEnum *self)
   return res;
 }
 
-void spanxe_destroy(void *p)
+void spanxe_destroy(SpanEnum *self)
 {
-  SpanEnum *self = (SpanEnum *)p;
   SpanNotEnum *sxe = (SpanNotEnum *)self->data;
   sxe->inc->destroy(sxe->inc);
   sxe->exc->destroy(sxe->exc);
@@ -924,12 +933,11 @@ SpanEnum *spanxe_create(Query *query, IndexReader *ir)
  *
  *****************************************************************************/
 
-void spanq_destroy(void *p)
+void spanq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
 /*****************************************************************************
@@ -952,48 +960,60 @@ char *spantq_to_s(Query *self, char *field)
   return res;
 }
 
-void spantq_destroy(void *p)
+static void spantq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   if (self->destroy_all) {
     Term *term = (Term *)sq->data;
     term_destroy(term);
   }
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
-void spantq_extract_terms(Query *self, Array *terms)
+static void spantq_extract_terms(Query *self, HashSet *terms)
 {
   Term *term = (Term *)((SpanQuery *)self->data)->data;
-  ary_append(terms, term);
+  hs_add(terms, term_clone(term));
 }
 
-Array *spantq_get_terms(Query *self)
+static HashSet *spantq_get_terms(Query *self)
 {
   Term *term = (Term *)((SpanQuery *)self->data)->data;
-  Array *terms = ary_create(1, &term_destroy);
-  ary_append(terms, term_clone(term));
+  HashSet *terms = term_set_create();
+  hs_add(terms, term_clone(term));
   return terms;
 }
 
+static uint spantq_hash(Query *self)
+{
+  return term_hash((Term *)((SpanQuery *)self->data)->data);
+}
+
+static int spantq_eq(Query *self, Query *o)
+{
+  return term_eq((Term *)((SpanQuery *)self->data)->data,
+                 (Term *)((SpanQuery *)o->data)->data);
+}
+
 Query *spantq_create(Term *term)
 {
   Query *self = q_create();
+
   SpanQuery *sq = ALLOC(SpanQuery);
   sq->data = term;
-
   sq->get_spans = &spante_create;
   sq->get_terms = &spantq_get_terms;
   sq->field = term->field;
+  self->data = sq;
 
   self->type = SPAN_TERM_QUERY;
-  self->data = sq;
-  self->create_weight = &spanw_create;
   self->extract_terms = &spantq_extract_terms;
   self->to_s = &spantq_to_s;
-  self->destroy = &spantq_destroy;
+  self->hash = &spantq_hash;
+  self->eq = &spantq_eq;
+  self->destroy_i = &spantq_destroy;
+  self->create_weight_i = &spanw_create;
   return self;
 }
 
@@ -1013,13 +1033,13 @@ char *spanfq_to_s(Query *self, char *field)
   return res;
 }
 
-void spanfq_extract_terms(Query *self, Array *terms)
+void spanfq_extract_terms(Query *self, HashSet *terms)
 {
   SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
   sfq->match->extract_terms(sfq->match, terms);
 }
 
-Array *spanfq_get_terms(Query *self)
+HashSet *spanfq_get_terms(Query *self)
 {
   SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
   SpanQuery *match_sq = (SpanQuery *)sfq->match->data;
@@ -1029,36 +1049,46 @@ Array *spanfq_get_terms(Query *self)
 Query *spanfq_rewrite(Query *self, IndexReader *ir)
 {
   SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
-  Query *clone = NULL;
-  Query *rewritten = sfq->match->rewrite(sfq->match, ir);
-  if (rewritten != sfq->match) {
-    clone = spanfq_create(rewritten, sfq->end);
-    sfq->match->rewritten = NULL; /* it will get destroyed with the clone */
-  }
+  Query *q, *rq;
 
-  if (clone != NULL) {
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = clone; /* some clauses rewrote */
-  } else {
-    return self;                    /* no clauses rewrote */
-  }
+  q = sfq->match;
+  rq = q->rewrite(q, ir);
+  if (rq == q || self->destroy_all) q_deref(q);
+  sfq->match = rq;
+
+  self->ref_cnt++;
+  return self;                    /* no clauses rewrote */
 }
 
-void spanfq_destroy(void *p)
+void spanfq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   SpanFirstQuery *sfq = (SpanFirstQuery *)sq->data;
-  if (self->destroy_all) sfq->match->destroy(sfq->match);
+  if (self->destroy_all) q_deref(sfq->match);
   free(sfq);
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint spanfq_hash(Query *self)
+{
+  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
+  return sfq->match->hash(sfq->match) ^ sfq->end;
+}
+
+static int spanfq_eq(Query *self, Query *o)
+{
+  SpanFirstQuery *sfq1 = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
+  SpanFirstQuery *sfq2 = (SpanFirstQuery *)((SpanQuery *)o->data)->data;
+  return sfq1->match->eq(sfq1->match, sfq2->match) && (sfq1->end == sfq2->end);
 }
 
 Query *spanfq_create(Query *match, int end)
 {
   Query *self = q_create();
+
   SpanQuery *sq = ALLOC(SpanQuery);
+
   SpanFirstQuery *sfq = ALLOC(SpanFirstQuery);
   sfq->match = match;
   sfq->end = end;
@@ -1067,14 +1097,16 @@ Query *spanfq_create(Query *match, int end)
   sq->get_spans = &spanfe_create;
   sq->get_terms = &spanfq_get_terms;
   sq->field = ((SpanQuery *)match->data)->field;
+  self->data = sq;
 
   self->type = SPAN_FIRST_QUERY;
-  self->data = sq;
-  self->create_weight = &spanw_create;
-  self->extract_terms = &spanfq_extract_terms;
   self->rewrite = &spanfq_rewrite;
+  self->extract_terms = &spanfq_extract_terms;
   self->to_s = &spanfq_to_s;
-  self->destroy = &spanfq_destroy;
+  self->hash = &spanfq_hash;
+  self->eq = &spanfq_eq;
+  self->destroy_i = &spanfq_destroy;
+  self->create_weight_i = &spanw_create;
   return self;
 }
 
@@ -1103,7 +1135,7 @@ char *spanoq_to_s(Query *self, char *field)
   return res;
 }
 
-void spanoq_extract_terms(Query *self, Array *terms)
+void spanoq_extract_terms(Query *self, HashSet *terms)
 {
   SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
   Query *clause;
@@ -1114,10 +1146,10 @@ void spanoq_extract_terms(Query *self, Array *terms)
   }
 }
 
-Array *spanoq_get_terms(Query *self)
+HashSet *spanoq_get_terms(Query *self)
 {
   SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  Array *terms = ary_create(soq->c_cnt, NULL);
+  HashSet *terms = term_set_create();
   Query *clause;
   int i;
   for (i = 0; i < soq->c_cnt; i++) {
@@ -1143,34 +1175,22 @@ SpanEnum *spanoq_get_spans(Query *self, IndexReader *ir)
 Query *spanoq_rewrite(Query *self, IndexReader *ir)
 {
   SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
-  Query *clone = NULL;
-
   Query *clause, *rewritten;
-  Query **new_clauses = ALLOC_N(Query *, soq->c_cnt);
   int i;
+  /* replace clauses with their rewritten queries */
   for (i = 0; i < soq->c_cnt; i++) {
     clause = soq->clauses[i];
     rewritten = clause->rewrite(clause, ir);
-    if ((clause != rewritten) && (clone == NULL)) {
-      clone = spanoq_create(new_clauses, soq->c_cnt);
-      /* The sub-clauses will be handled by the original query */
-      clone->destroy_all = false;
-    }
-    new_clauses[i] = rewritten;
+    if ((rewritten == clause) || self->destroy_all) q_deref(clause);
+    soq->clauses[i] = rewritten;
   }
 
-  if (clone != NULL) {
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = clone; /* some clauses rewrote */
-  } else {
-    free(new_clauses);              /* no clauses rewrote */
-    return self;
-  }
+  self->ref_cnt++;
+  return self;
 }
 
-void spanoq_destroy(void *p)
+void spanoq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   SpanOrQuery *soq = (SpanOrQuery *)sq->data;
 
@@ -1179,7 +1199,7 @@ void spanoq_destroy(void *p)
     int i;
     for (i = 0; i < soq->c_cnt; i++) {
       clause = soq->clauses[i];
-      clause->destroy(clause);
+      q_deref(clause);
     }
     free(soq->clauses);
   }
@@ -1187,13 +1207,44 @@ void spanoq_destroy(void *p)
 
   free(soq);
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint spanoq_hash(Query *self)
+{
+  int i;
+  uint hash = 0;
+  Query *q;
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+
+  for (i = 0; i < soq->c_cnt; i++) {
+    q = soq->clauses[i];
+    hash ^= q->hash(q);
+  }
+  return hash;
+}
+
+static int spanoq_eq(Query *self, Query *o)
+{
+  int i;
+  Query *q1, *q2;
+  SpanOrQuery *soq1 = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+  SpanOrQuery *soq2 = (SpanOrQuery *)((SpanQuery *)o->data)->data;
+  if (soq1->c_cnt != soq2->c_cnt) return false;
+  for (i = 0; i < soq1->c_cnt; i++) {
+    q1 = soq1->clauses[i];
+    q2 = soq2->clauses[i];
+    if (!q1->eq(q1, q2)) return false;
+  }
+  return true;
 }
 
 Query *spanoq_create(Query **clauses, int c_cnt)
 {
   Query *self = q_create();
+
   SpanQuery *sq = ALLOC(SpanQuery);
+
   SpanOrQuery *soq = ALLOC(SpanOrQuery);
   soq->clauses = clauses;
   soq->c_cnt = c_cnt;
@@ -1202,14 +1253,16 @@ Query *spanoq_create(Query **clauses, int c_cnt)
   sq->get_spans = &spanoq_get_spans;
   sq->get_terms = &spanoq_get_terms;
   sq->field = ((SpanQuery *)clauses[0]->data)->field;
+  self->data = sq;
 
   self->type = SPAN_OR_QUERY;
-  self->data = sq;
-  self->create_weight = &spanw_create;
-  self->extract_terms = &spanoq_extract_terms;
   self->rewrite = &spanoq_rewrite;
+  self->extract_terms = &spanoq_extract_terms;
   self->to_s = &spanoq_to_s;
-  self->destroy = &spanoq_destroy;
+  self->hash = &spanoq_hash;
+  self->eq = &spanoq_eq;
+  self->destroy_i = &spanoq_destroy;
+  self->create_weight_i = &spanw_create;
   return self;
 }
 
@@ -1240,7 +1293,7 @@ char *spannq_to_s(Query *self, char *field)
   return res;
 }
 
-void spannq_extract_terms(Query *self, Array *terms)
+void spannq_extract_terms(Query *self, HashSet *terms)
 {
   SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
   Query *clause;
@@ -1251,10 +1304,10 @@ void spannq_extract_terms(Query *self, Array *terms)
   }
 }
 
-Array *spannq_get_terms(Query *self)
+HashSet *spannq_get_terms(Query *self)
 {
   SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  Array *terms = ary_create(snq->c_cnt, NULL);
+  HashSet *terms = term_set_create();
   Query *clause;
   int i;
   for (i = 0; i < snq->c_cnt; i++) {
@@ -1281,34 +1334,21 @@ SpanEnum *spannq_get_spans(Query *self, IndexReader *ir)
 Query *spannq_rewrite(Query *self, IndexReader *ir)
 {
   SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
-  Query *clone = NULL;
-
   Query *clause, *rewritten;
-  Query **new_clauses = ALLOC_N(Query *, snq->c_cnt);
   int i;
   for (i = 0; i < snq->c_cnt; i++) {
     clause = snq->clauses[i];
     rewritten = clause->rewrite(clause, ir);
-    if ((clause != rewritten) && (clone == NULL)) {
-      clone = spannq_create(new_clauses, snq->c_cnt, snq->slop, snq->in_order);
-      /* The sub-clauses will be handled by the original query */
-      clone->destroy_all = false;
-    }
-    new_clauses[i] = rewritten;
+    if ((rewritten == clause) || self->destroy_all) q_deref(clause);
+    snq->clauses[i] = rewritten;
   }
 
-  if (clone != NULL) {
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = clone; /* some clauses rewrote */
-  } else {
-    free(new_clauses);              /* no clauses rewrote */
-    return self;
-  }
+  self->ref_cnt++;
+  return self;
 }
 
-void spannq_destroy(void *p)
+void spannq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   SpanNearQuery *snq = (SpanNearQuery *)sq->data;
 
@@ -1317,21 +1357,57 @@ void spannq_destroy(void *p)
     int i;
     for (i = 0; i < snq->c_cnt; i++) {
       clause = snq->clauses[i];
-      clause->destroy(clause);
+      q_deref(clause);
     }
     free(snq->clauses);
   }
 
-
   free(snq);
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint spannq_hash(Query *self)
+{
+  int i;
+  uint hash = 0;
+  Query *q;
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+
+  for (i = 0; i < snq->c_cnt; i++) {
+    q = snq->clauses[i];
+    hash ^= q->hash(q);
+  }
+  return ((hash ^ snq->slop) << 1) | snq->in_order;
+}
+
+static int spannq_eq(Query *self, Query *o)
+{
+  int i;
+  Query *q1, *q2;
+  SpanNearQuery *snq1 = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+  SpanNearQuery *snq2 = (SpanNearQuery *)((SpanQuery *)o->data)->data;
+  if (snq1->c_cnt != snq2->c_cnt ||
+      snq1->slop != snq2->slop ||
+      snq1->in_order != snq2->in_order) {
+    return false;
+  }
+
+  for (i = 0; i < snq1->c_cnt; i++) {
+    q1 = snq1->clauses[i];
+    q2 = snq2->clauses[i];
+    if (!q1->eq(q1, q2)) return false;
+  }
+
+  return true;
 }
 
 Query *spannq_create(Query **clauses, int c_cnt, int slop, bool in_order)
 {
   Query *self = q_create();
+
   SpanQuery *sq = ALLOC(SpanQuery);
+
   SpanNearQuery *snq = ALLOC(SpanNearQuery);
   snq->clauses = clauses;
   snq->c_cnt = c_cnt;
@@ -1341,16 +1417,17 @@ Query *spannq_create(Query **clauses, int c_cnt, int slop, bool in_order)
 
   sq->get_spans = &spannq_get_spans;
   sq->get_terms = &spannq_get_terms;
-
   sq->field = ((SpanQuery *)clauses[0]->data)->field;
+  self->data = sq;
 
   self->type = SPAN_NEAR_QUERY;
-  self->data = sq;
-  self->create_weight = &spanw_create;
-  self->extract_terms = &spannq_extract_terms;
   self->rewrite = &spannq_rewrite;
+  self->extract_terms = &spannq_extract_terms;
   self->to_s = &spannq_to_s;
-  self->destroy = &spannq_destroy;
+  self->hash = &spannq_hash;
+  self->eq = &spannq_eq;
+  self->destroy_i = &spannq_destroy;
+  self->create_weight_i = &spanw_create;
   return self;
 }
 
@@ -1372,16 +1449,16 @@ char *spanxq_to_s(Query *self, char *field)
   return res;
 }
 
-void spanxq_extract_terms(Query *self, Array *terms)
+void spanxq_extract_terms(Query *self, HashSet *terms)
 {
   SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
   sxq->inc->extract_terms(sxq->inc, terms);
 }
 
-Array *spanxq_get_terms(Query *self)
+HashSet *spanxq_get_terms(Query *self)
 {
   SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  Array *terms = ary_create(1, NULL);
+  HashSet *terms = term_set_create();
   sxq->inc->extract_terms(sxq->inc, terms);
   return terms;
 }
@@ -1389,48 +1466,60 @@ Array *spanxq_get_terms(Query *self)
 Query *spanxq_rewrite(Query *self, IndexReader *ir)
 {
   SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
-  Query *clone = NULL;
-  Query *inc, *exc;
-  Query *inc_rewritten, *exc_rewritten;
-
-  inc = sxq->inc;
-  inc_rewritten = inc->rewrite(inc, ir);
-  exc = sxq->exc;
-  exc_rewritten = exc->rewrite(exc, ir);
-  if ((inc_rewritten != inc) || (exc_rewritten != exc)) {
-    clone = spanxq_create(inc_rewritten, exc_rewritten);
-    /* The sub-clauses will be handled by the original query */
-    clone->destroy_all = false;
-  }
+  Query *q, *rq;
 
-  if (clone != NULL) {
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = clone; /* some clauses rewrote */
-  } else {
-    return self; /* no clauses rewrote */
-  }
+  /* rewrite inclusive query */
+  q = sxq->inc;
+  rq = q->rewrite(q, ir);
+  if (rq == q || self->destroy_all) q_deref(q);
+  sxq->inc = rq;
+
+  /* rewrite exclusive query */
+  q = sxq->exc;
+  rq = q->rewrite(q, ir);
+  if (rq == q || self->destroy_all) q_deref(q);
+  sxq->exc = rq;
+
+  self->ref_cnt++;
+  return self;
 }
 
-void spanxq_destroy(void *p)
+void spanxq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   SpanQuery *sq = (SpanQuery *)self->data;
   SpanNotQuery *sxq = (SpanNotQuery *)sq->data;
 
   if (self->destroy_all) {
-    sxq->inc->destroy(sxq->inc);
-    sxq->exc->destroy(sxq->exc);
+    q_deref(sxq->inc);
+    q_deref(sxq->exc);
   }
 
   free(sxq);
   free(sq);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
+static uint spanxq_hash(Query *self)
+{
+  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
+  return sxq->inc->hash(sxq->inc) ^ sxq->exc->hash(sxq->exc);
+}
+
+static int spanxq_eq(Query *self, Query *o)
+{
+  SpanNotQuery *sxq1 = (SpanNotQuery *)((SpanQuery *)self->data)->data;
+  SpanNotQuery *sxq2 = (SpanNotQuery *)((SpanQuery *)o->data)->data;
+  return sxq1->inc->eq(sxq1->inc, sxq2->inc) && 
+         sxq1->exc->eq(sxq1->exc, sxq2->exc);
+}
+
+
 Query *spanxq_create(Query *inc, Query *exc)
 {
   Query *self = q_create();
+
   SpanQuery *sq = ALLOC(SpanQuery);
+
   SpanNotQuery *sxq = ALLOC(SpanNotQuery);
   sxq->inc = inc;
   sxq->exc = exc;
@@ -1439,14 +1528,17 @@ Query *spanxq_create(Query *inc, Query *exc)
   sq->get_spans = &spanxe_create;
   sq->get_terms = &spanxq_get_terms;
   sq->field = ((SpanQuery *)inc->data)->field;
+  self->data = sq;
 
   self->type = SPAN_NOT_QUERY;
-  self->data = sq;
-  self->create_weight = &spanw_create;
-  self->extract_terms = &spanxq_extract_terms;
   self->rewrite = &spanxq_rewrite;
+  self->extract_terms = &spanxq_extract_terms;
   self->to_s = &spanxq_to_s;
-  self->destroy = &spanxq_destroy;
+  self->hash = &spanxq_hash;
+  self->eq = &spanxq_eq;
+  self->destroy_i = &spanxq_destroy;
+  self->create_weight_i = &spanw_create;
+
   return self;
 }
 
@@ -1512,24 +1604,23 @@ bool spansc_skip_to(Scorer *self, int target)
 
 Explanation *spansc_explain(Scorer *self, int target)
 {
+  Explanation *tf_explanation;
   SpanScorer *spansc = (SpanScorer *)self->data;
   float phrase_freq;
   self->skip_to(self, target);
-  phrase_freq = (self->doc == target) ? spansc->freq : 0.0;
+  phrase_freq = (self->doc == target) ? spansc->freq : (float)0.0;
 
-  Explanation *tf_explanation = expl_create(sim_tf(self->similarity, phrase_freq),
+  tf_explanation = expl_create(sim_tf(self->similarity, phrase_freq),
       strfmt("tf(phrase_freq(%f)", phrase_freq));
 
   return tf_explanation;
 }
 
-void spansc_destroy(void *p)
+void spansc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   SpanScorer *spansc = (SpanScorer *)self->data;
   if (spansc->spans) spansc->spans->destroy(spansc->spans);
-  //free(spansc->norms);
-  scorer_destroy(p);
+  scorer_destroy_i(self);
 }
 
 Scorer *spansc_create(Weight *weight, IndexReader *ir)