ferret 0.3.2 → 0.9.0

data/ext/q_prefix.c

@@ -0,0 +1,75 @@
+#include <string.h>
+#include "search.h"
+
+/****************************************************************************
+ *
+ * PrefixQuery
+ *
+ ****************************************************************************/
+
+char *prq_to_s(Query *self, char *field) 
+{
+  char *buffer, *bptr;
+  Term *term = (Term *)self->data;
+  int tlen = strlen(term->text);
+  int flen = strlen(term->field);
+  bptr = buffer = ALLOC_N(char, tlen + flen + 35);
+
+  if (strcmp(term->field, field) != 0) {
+    sprintf(bptr, "%s:", term->field);
+    bptr++;
+  }
+  sprintf(bptr, "%s*", term->text);
+  if (self->boost != 1.0) {
+    *bptr = '^';
+    dbl_to_s(++bptr, self->boost);
+  }
+
+  return buffer;
+}
+
+Query *prq_rewrite(Query *self, IndexReader *ir)
+{
+  Term *prefix = (Term *)self->data;
+  TermEnum *te = ir->terms_from(ir, prefix);
+  char *prefix_text = prefix->text;
+  int prefix_length = strlen(prefix_text);
+  char *prefix_field = prefix->field;
+  Query *tq;
+  Query *bq = bq_create(true);
+
+  do { 
+    TermBuffer *tb = te->tb_curr;
+    if (!tb || strcmp(tb->field, prefix_field) != 0 ||
+      strncmp(tb->text, prefix_text, prefix_length) != 0) {
+      break;
+    }
+    tq = tq_create(term_create(tb->field, tb->text)); // found a match
+    tq->boost = self->boost;                          // set the boost
+    bq_add_query(bq, tq, BC_SHOULD);                  // add to query
+  } while (te->next(te));
+  te->close(te);
+
+  if (self->rewritten) self->rewritten->destroy(self->rewritten);
+  return self->rewritten = bq;
+}
+
+void prq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  if (self->destroy_all) term_destroy((Term *)self->data);
+  q_destroy(self);
+}
+
+Query *prefixq_create(Term *prefix)
+{
+  Query *self = q_create();
+  self->data = prefix;
+  self->type = PREFIX_QUERY;
+  self->create_weight = NULL;
+  self->to_s = &prq_to_s;
+  self->rewrite = &prq_rewrite;
+  self->destroy = &prq_destroy;
+
+  return self;
+}

data/ext/q_range.c

@@ -0,0 +1,247 @@
+#include <string.h>
+#include "search.h"
+
+/*****************************************************************************
+ *
+ * Range
+ *
+ *****************************************************************************/
+
+char *range_to_s(Range *range, char *field, float boost)
+{
+  char *buffer, *bptr;
+  int flen, llen, ulen;
+
+  flen = strlen(range->field);
+  llen = range->lower_term ? strlen(range->lower_term) : 0;
+  ulen = range->upper_term ? strlen(range->upper_term) : 0;
+  buffer = ALLOC_N(char, flen + llen + ulen + 40);
+  bptr = buffer;
+
+  if (strcmp(field, range->field)) {
+    memcpy(buffer, range->field, flen * sizeof(char));
+    bptr += flen;
+    *bptr = ':';
+    bptr++;
+  }
+
+  if (range->lower_term) {
+    *bptr = range->include_lower ? '[' : '{';
+    bptr++;
+    memcpy(bptr, range->lower_term, llen);
+    bptr += llen;
+  } else {
+    *bptr = '<';
+    bptr++;
+  }
+
+  if (range->upper_term && range->lower_term) {
+    *bptr = ' '; bptr++;
+  }
+
+  if (range->upper_term) {
+    memcpy(bptr, range->upper_term, ulen);
+    bptr += ulen;
+    *bptr = range->include_upper ? ']' : '}';
+    bptr++;
+  } else {
+    *bptr = '>';
+    bptr++;
+  }
+
+  *bptr = 0;
+  if (boost != 1.0) {
+    char dbuf[32];
+    dbl_to_s(dbuf, boost);
+    sprintf(bptr, "^%s", dbuf);
+  }
+  return buffer;
+}
+
+void range_destroy(void *p)
+{
+  Range *range = (Range *)p;
+  free(range->field);
+  if (range->lower_term) free(range->lower_term);
+  if (range->upper_term) free(range->upper_term);
+  free(range);
+}
+
+Range *range_create(const char *field, char *lower_term, char *upper_term,
+    bool include_lower, bool include_upper)
+{
+  Range *range; 
+
+  if (!lower_term && !upper_term) 
+    eprintf(ARG_ERROR, "At least one value must be non-nil");
+  if (include_lower && !lower_term) 
+    eprintf(ARG_ERROR, "The lower bound must be non-nil to be inclusive");
+  if (include_upper && !upper_term) 
+    eprintf(ARG_ERROR, "The upper bound must be non-nil to be inclusive");
+  if (upper_term && lower_term && (strcmp(upper_term, lower_term) < 0))
+    eprintf(ARG_ERROR,
+        "The lower bound must less than the upper bound, %s > %s",
+        upper_term, upper_term);
+
+  range = ALLOC(Range);
+
+  range->field = estrdup((char *)field);
+  range->lower_term = lower_term ? estrdup(lower_term) : NULL;
+  range->upper_term = upper_term ? estrdup(upper_term) : NULL;
+  range->include_lower = include_lower;
+  range->include_upper = include_upper;
+  return range;
+}
+
+/***************************************************************************
+ *
+ * RangeFilter
+ *
+ ***************************************************************************/
+
+void rfilt_destroy(void *p)
+{
+  Filter *self = (Filter *)p;
+  range_destroy(self->data);
+  filt_destroy(self);
+}
+
+char *rfilt_to_s(Filter *self)
+{
+  Range *range = (Range *)self->data;
+  return range_to_s(range, "", 1.0);
+}
+
+BitVector *rfilt_get_bv(Filter *self, IndexReader *ir)
+{
+  BitVector *bv = bv_create_size(ir->max_doc(ir));
+  Range *range = (Range *)self->data;
+  char *field = range->field;
+  char *lower_term = range->lower_term ? range->lower_term : (char *)EMPTY_STRING;
+  char *upper_term = range->upper_term;
+  bool include_upper = range->include_upper;
+
+  Term *term_from = term_create(range->field, lower_term);
+  Term term;
+  TermBuffer *tb;
+  TermEnum* te;
+  TermDocEnum *tde;
+  bool check_lower;
+
+  te = ir->terms_from(ir, term_from);
+  if (te->tb_curr == NULL) {
+    return bv;
+  }
+            
+  check_lower = false;
+  if (!range->include_lower) // make adjustments to set to exclusive
+      check_lower = true;
+        
+  tde = ir->term_docs(ir);
+  tb = te->tb_curr;
+  term.text = tb->text;
+  do {
+    if (tb && strcmp(tb->field, field) == 0) {
+      if (!check_lower || lower_term == EMPTY_STRING ||
+          strcmp(tb->text, lower_term) > 0) {
+        check_lower = false;
+        if (upper_term) {
+          int compare = strcmp(upper_term, tb->text);
+          /* if beyond the upper term, or is exclusive and
+           * this is equal to the upper term, break out */
+          if ((compare < 0) ||
+              (!include_upper && compare==0)) {
+              break;
+          }
+        }
+        /* we have a good term, find the docs */
+        /* text is already pointing to term buffer text */
+        term.field = tb->field;
+        tde->seek(tde, &term);
+        while (tde->next(tde)) {
+          bv_set(bv, tde->doc_num(tde));
+          //printf("Setting %d\n", tde->doc_num(tde));
+        }
+      }
+    } else {
+      break;
+    }
+  } while (te->next(te));
+          
+  tde->close(tde);
+  te->close(te);
+  term_destroy(term_from);
+
+  return bv;
+}
+
+Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
+    bool include_lower, bool include_upper)
+{
+  Filter *self;
+  Range *range = range_create(field, lower_term, upper_term,
+      include_lower, include_upper); 
+
+  self = filt_create("RangeFilter");
+  self->data = range;
+  self->get_bv = &rfilt_get_bv;
+  self->to_s = &rfilt_to_s;
+  self->destroy = &rfilt_destroy;
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * RangeQuery
+ *
+ *****************************************************************************/
+
+char *rq_to_s(Query *self, char *field)
+{
+  Range *range = (Range *)self->data;
+  return range_to_s(range, field, self->boost);
+}
+
+void rq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  range_destroy(self->data);
+  q_destroy(self);
+}
+
+Query *rq_rewrite(Query *self, IndexReader *ir)
+{
+  Range *r = (Range *)self->data;
+  Filter *filter = rfilt_create(r->field, r->lower_term, r->upper_term,
+      r->include_lower, r->include_upper);
+  if (self->rewritten) self->rewritten->destroy(self->rewritten);
+  return self->rewritten = csq_create(filter);
+}
+
+Query *rq_create_less(const char *field, char *upper_term, bool include_upper)
+{
+  return rq_create(field, NULL, upper_term, false, include_upper);
+}
+
+Query *rq_create_more(const char *field, char *lower_term, bool include_lower)
+{
+  return rq_create(field, lower_term, NULL, include_lower, false);
+}
+
+Query *rq_create(const char *field, char *lower_term, char *upper_term,
+    bool include_lower, bool include_upper)
+{
+  Query *self;
+  Range *range = range_create(field, lower_term, upper_term,
+      include_lower, include_upper); 
+
+  self = q_create();
+
+  self->type = RANGE_QUERY;
+  self->data = range;
+  self->create_weight = NULL;
+  self->rewrite = &rq_rewrite;
+  self->to_s = &rq_to_s;
+  self->destroy = &rq_destroy;
+  return self;
+}

data/ext/q_span.c

@@ -0,0 +1,1566 @@
+#include <string.h>
+#include "search.h"
+
+
+/*****************************************************************************
+ *
+ * NearSpanEnum
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * SpanWeight
+ *
+ *****************************************************************************/
+
+Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
+{
+  char *query_str = self->query->to_s(self->query, "");
+  Array *terms = (Array *)self->data;
+  char *field = ((SpanQuery *)self->query->data)->field;
+  char *doc_freqs = NULL;
+  int df_i = 0, i;
+  Term *t;
+
+
+  for (i = 0; i < terms->size; i++) {
+    t = (Term *)terms->elems[i];
+    REALLOC_N(doc_freqs, char, df_i + strlen(t->text) + 23);
+    sprintf(doc_freqs + df_i, "%s=%d, ", t->text, ir->doc_freq(ir, t));
+    df_i = strlen(doc_freqs);
+  }
+  /* remove the ',' at the end of the string if it exists */
+  if (terms->size > 0) {
+    df_i -= 2;
+    doc_freqs[df_i] = '\0';
+  } else {
+    doc_freqs = "";
+  }
+
+  Explanation *expl = expl_create(0.0,
+      epstrdup("weight(%s in %d), product of:",
+        strlen(query_str) + 20,
+        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,
+      epstrdup("idf(%s: %s)", strlen(field) + df_i, field, doc_freqs));
+  Explanation *idf_expl2 = expl_create(self->idf,
+      epstrdup("idf(%s: %s)", strlen(field) + df_i, field, doc_freqs));
+  if (terms->size > 0) free(doc_freqs); /* only free if allocated */
+
+  /* explain query weight */
+  Explanation *query_expl = expl_create(0.0,
+      epstrdup("query_weight(%s), product of:", strlen(query_str), query_str));
+
+  if (self->query->boost != 1.0) {
+    expl_add_detail(query_expl, expl_create(self->query->boost, estrdup("boost")));
+  }
+
+  expl_add_detail(query_expl, idf_expl1);
+
+  Explanation *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;
+
+  expl_add_detail(expl, query_expl);
+
+  /* explain field weight */
+  Explanation *field_expl = expl_create(0.0, 
+      epstrdup("field_weight(%s:%s in %d), product of:",
+        strlen(field) + strlen(query_str) + 20,
+        field, query_str, target));
+  free(query_str);
+
+  Scorer *scorer = self->scorer(self, ir);
+  Explanation *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,
+      epstrdup("field_norm(field=%s, doc=%d)",
+        strlen(field) + 20, field, target));
+  expl_add_detail(field_expl, field_norm_expl);
+
+  field_expl->value = tf_expl->value * idf_expl2->value * field_norm_expl->value;
+
+  /* combine them */
+  if (query_expl->value == 1.0) {
+    expl_destoy(expl);
+    return field_expl;
+  } else {
+    expl->value = (query_expl->value * field_expl->value);
+    expl_add_detail(expl, field_expl);
+    return expl;
+  }
+}
+
+char *spanw_to_s(Weight *self)
+{
+  char dbuf[32];
+  dbl_to_s(dbuf, self->value);
+  return epstrdup("SpanWeight(%s)", strlen(dbuf), dbuf);
+}
+
+void spanw_destroy(void *p)
+{
+  Weight *self = (Weight *)p;
+  ary_destroy(self->data);
+  free(p);
+}
+
+Weight *spanw_create(Query *query, Searcher *searcher)
+{
+  Weight *self = ALLOC(Weight);
+  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;
+  self->scorer    = &spansc_create;
+  self->explain   = &spanw_explain;
+  self->to_s      = &spanw_to_s;
+  self->destroy   = &spanw_destroy;
+  self->sum_of_squared_weights = &w_sum_of_squared_weights;
+
+  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;
+
+  return self;
+}
+
+
+/*****************************************************************************
+ *
+ * SpanTermEnum
+ *
+ *****************************************************************************/
+
+bool spante_next(SpanEnum *self)
+{
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  TermDocEnum *tde = ste->positions;
+
+  if (ste->count == ste->freq) {
+    if (! tde->next(tde)) {
+      ste->doc = INT_MAX;
+      return false;
+    }
+    ste->doc = tde->doc_num(tde);
+    ste->freq = tde->freq(tde);
+    ste->count = 0;
+  }
+  ste->position = tde->next_position(tde);
+  ste->count++;
+  return true;
+}
+
+bool spante_skip_to(SpanEnum *self, int target)
+{
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  TermDocEnum *tde = ste->positions;
+
+  /* are we already at the correct position? */
+  if (ste->doc >= target) return true;
+
+  if (! tde->skip_to(tde, target)) {
+    ste->doc = INT_MAX;
+    return false;
+  }
+
+  ste->doc = tde->doc_num(tde);
+  ste->freq = tde->freq(tde);
+  ste->count = 0;
+
+  ste->position = tde->next_position(tde);
+  ste->count++;
+  return true;
+}
+
+int  spante_doc(SpanEnum *self)
+{
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  return ste->doc;
+}
+
+int  spante_start(SpanEnum *self)
+{
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  return ste->position;
+}
+
+int  spante_end(SpanEnum *self)
+{
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  return ste->position + 1;
+}
+
+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;
+  char *str = ALLOC_N(char, len + 40);
+
+  if (self->doc(self) < 0) {
+      sprintf(pos_str, "START");
+  } else {
+    if (self->doc(self) == INT_MAX) {
+      sprintf(pos_str, "END");
+    } else {
+      pos = ((SpanTermEnum *)self->data)->position;
+      sprintf(pos_str, "%d", self->doc(self) - pos);
+    }
+  }
+  sprintf("SpanTermEnum(%s)@%s", query_str, pos_str);
+  free(query_str);
+  return str;
+}
+
+void spante_destroy(void *p)
+{
+  SpanEnum *self = (SpanEnum *)p;
+  SpanTermEnum *ste = (SpanTermEnum *)self->data;
+  TermDocEnum *tde = ste->positions;
+  tde->close(tde);
+  free(ste);
+  free(self);
+}
+
+SpanEnum *spante_create(Query *query, IndexReader *ir)
+{
+  Term *term = (Term *)((SpanQuery *)query->data)->data;
+  SpanEnum *self = ALLOC(SpanEnum);
+
+  SpanTermEnum *ste = ALLOC(SpanTermEnum);
+  ste->positions = ir_term_positions_for(ir, term);
+  ste->position = -1;
+  ste->doc = -1;
+  ste->count = 0;
+  ste->freq = 0;
+
+  self->data = ste;
+
+  self->query = query;
+  self->next = &spante_next;
+  self->skip_to = &spante_skip_to;
+  self->doc = &spante_doc;
+  self->start = &spante_start;
+  self->end = &spante_end;
+  self->destroy = &spante_destroy;
+  self->to_s = &spante_to_s;
+
+  return self;
+}
+
+
+/*****************************************************************************
+ *
+ * SpanFirstEnum
+ *
+ *****************************************************************************/
+
+bool spanfe_next(SpanEnum *self)
+{
+  SpanEnum *se = (SpanEnum *)(self->data);
+  int end = ((SpanFirstQuery *)((SpanQuery *)self->query->data)->data)->end;
+  while (se->next(se)) { /* scan to next match */
+    if (se->end(se) <= end) return true;
+  }
+  return false;
+}
+
+bool spanfe_skip_to(SpanEnum *self, int target)
+{
+  SpanEnum *se = (SpanEnum *)(self->data);
+  int end = ((SpanFirstQuery *)((SpanQuery *)self->query->data)->data)->end;
+
+  if (! se->skip_to(se, target)) return false;
+
+  if (se->end(se) <= end) /* there is a match */
+    return true;
+
+  return se->next(se);    /* scan to next match */
+}
+
+int  spanfe_doc(SpanEnum *self)
+{
+  SpanEnum *se = (SpanEnum *)(self->data);
+  return se->doc(se);
+}
+
+int  spanfe_start(SpanEnum *self)
+{
+  SpanEnum *se = (SpanEnum *)(self->data);
+  return se->start(se);
+}
+
+int  spanfe_end(SpanEnum *self)
+{
+  SpanEnum *se = (SpanEnum *)(self->data);
+  return se->end(se);
+}
+
+char *spanfe_to_s(SpanEnum *self) 
+{
+  char *field = ((SpanQuery *)self->query->data)->field;
+  char *query_str = self->query->to_s(self->query, field);
+  char *res = epstrdup("SpanFirstEnum(%s)", strlen(query_str), query_str);
+  free(query_str);
+  return res;
+}
+
+void spanfe_destroy(void *p)
+{
+  SpanEnum *self = (SpanEnum *)p;
+  SpanEnum *se = (SpanEnum *)self->data;
+  se->destroy(se);
+  free(self);
+}
+
+SpanEnum *spanfe_create(Query *query, IndexReader *ir)
+{
+  SpanEnum *self = ALLOC(SpanEnum);
+  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)query->data)->data;
+
+  self->data = ((SpanQuery *)sfq->match->data)->get_spans(sfq->match, ir);
+
+  self->query = query;
+  self->next = &spanfe_next;
+  self->skip_to = &spanfe_skip_to;
+  self->doc = &spanfe_doc;
+  self->start = &spanfe_start;
+  self->end = &spanfe_end;
+  self->destroy = &spanfe_destroy;
+  self->to_s = &spanfe_to_s;
+
+  return self;
+}
+
+
+/*****************************************************************************
+ *
+ * SpanOrEnum
+ *
+ *****************************************************************************/
+
+bool span_less_than(void *p1, void *p2)
+{
+  SpanEnum *s1 = (SpanEnum *)p1;
+  SpanEnum *s2 = (SpanEnum *)p2;
+  int doc_diff, start_diff;
+  doc_diff = s1->doc(s1) - s2->doc(s2);
+  if (doc_diff == 0) {
+    start_diff = s1->start(s1) - s2->start(s2);
+    if (start_diff == 0) {
+      return s1->end(s1) < s2->end(s2);
+    } else {
+      return start_diff < 0;
+    }
+  } else {
+    return doc_diff < 0;
+  }
+}
+
+bool spanoe_next(SpanEnum *self)
+{
+  SpanOrEnum *soe = (SpanOrEnum *)self->data;
+  SpanEnum *se;
+  int i;
+
+  if (soe->first_time) { /* first time -- initialize */
+    for (i = 0; i < soe->s_cnt; i++) {
+      se = soe->span_enums[i];
+      if (se->next(se)) /* move to first entry */
+        pq_push(soe->queue, se);
+    }
+    soe->first_time = false;
+    return soe->queue->count != 0;
+  }
+
+  if (soe->queue->count == 0) return false; /* all done */
+
+  se = (SpanEnum *)pq_top(soe->queue);
+  if (se->next(se)) { /* move to next */
+    pq_down(soe->queue);
+    return true;
+  }
+
+  pq_pop(soe->queue); /* exhausted a clause */
+
+  return soe->queue->count != 0;
+}
+
+bool spanoe_skip_to(SpanEnum *self, int target)
+{
+  SpanOrEnum *soe = (SpanOrEnum *)self->data;
+  SpanEnum *se;
+  int i;
+
+  if (soe->first_time) { /* first time -- initialize */
+    for (i = 0; i < soe->s_cnt; i++) {
+      se = soe->span_enums[i];
+      if (se->skip_to(se, target)) /* move to target */
+        pq_push(soe->queue, se);
+    }
+    soe->first_time = false;
+  } else {
+    while ((soe->queue->count != 0) &&
+        ((se=(SpanEnum *)pq_top(soe->queue))->doc(se) < target)) {
+      if (se->skip_to(se, target)) {
+        pq_down(soe->queue);
+      } else {
+        pq_pop(soe->queue);
+      }
+    }
+  }
+
+  return soe->queue->count != 0;
+}
+
+#define GET_TOP_SOE SpanOrEnum *soe = (SpanOrEnum *)self->data;\
+                    SpanEnum *se = (SpanEnum *)pq_top(soe->queue)
+int  spanoe_doc(SpanEnum *self)
+{
+  GET_TOP_SOE;
+  return se->doc(se);
+}
+
+int  spanoe_start(SpanEnum *self)
+{
+  GET_TOP_SOE;
+  return se->start(se);
+}
+
+int  spanoe_end(SpanEnum *self)
+{
+  GET_TOP_SOE;
+  return se->end(se);
+}
+
+char *spanoe_to_s(SpanEnum *self) 
+{
+  SpanOrEnum *soe = (SpanOrEnum *)self->data;
+  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);
+  char *str = ALLOC_N(char, len + 80);
+
+  if (soe->first_time) {
+      sprintf(doc_str, "START");
+  } else {
+    if (soe->queue->count == 0) {
+      sprintf(doc_str, "END");
+    } else {
+      sprintf(doc_str, "%d:%d-%d", self->doc(self),
+          self->start(self), self->end(self));
+    }
+  }
+  sprintf("SpanOrEnum(%s)@%s", query_str, doc_str);
+  free(query_str);
+  return str;
+}
+
+void spanoe_destroy(void *p)
+{
+  SpanEnum *self = (SpanEnum *)p, *se;
+  SpanOrEnum *soe = (SpanOrEnum *)self->data;
+  int i;
+  pq_destroy(soe->queue);
+  for (i = 0; i < soe->s_cnt; i++) {
+    se = soe->span_enums[i];
+    se->destroy(se);
+  }
+  free(soe->span_enums);
+  free(soe);
+  free(self);
+}
+
+SpanEnum *spanoe_create(Query *query, IndexReader *ir)
+{
+  Query *clause;
+  SpanEnum *self = ALLOC(SpanEnum);
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)query->data)->data;
+  SpanOrEnum *soe = ALLOC(SpanOrEnum);
+  int i;
+  soe->first_time = true;
+  soe->s_cnt = soq->c_cnt;
+  soe->span_enums = ALLOC_N(SpanEnum *, soe->s_cnt);
+  for (i = 0; i < soe->s_cnt; i++) {
+    clause = soq->clauses[i];
+    soe->span_enums[i] = ((SpanQuery *)clause->data)->get_spans(clause, ir);
+  }
+  
+  soe->queue = pq_create(soe->s_cnt, &span_less_than);
+
+  self->data = soe;
+
+  self->query = query;
+  self->next = &spanoe_next;
+  self->skip_to = &spanoe_skip_to;
+  self->doc = &spanoe_doc;
+  self->start = &spanoe_start;
+  self->end = &spanoe_end;
+  self->destroy = &spanoe_destroy;
+  self->to_s = &spanoe_to_s;
+
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanNearEnum
+ *
+ *****************************************************************************/
+
+#define SNE_NEXT() do {\
+  sne->current = (sne->current+1) % sne->s_cnt;\
+  se = sne->span_enums[sne->current];\
+} while (0);
+
+bool sne_init(SpanNearEnum *sne)
+{
+  SpanEnum *se = sne->span_enums[sne->current];
+  int prev_doc = se->doc(se);
+  int i;
+
+  for (i = 1; i < sne->s_cnt; i++) {
+    SNE_NEXT();
+    if (!se->skip_to(se, prev_doc)) return false;
+    prev_doc = se->doc(se);
+  }
+  return true;
+}
+
+bool sne_goto_next_doc(SpanNearEnum *sne)
+{
+  SpanEnum *se = sne->span_enums[sne->current];
+  int prev_doc = se->doc(se);
+
+  SNE_NEXT();
+
+  while (se->doc(se) < prev_doc) {
+    if (! se->skip_to(se, prev_doc)) return false;
+    prev_doc = se->doc(se);
+    SNE_NEXT();
+  }
+  return true;
+}
+
+bool sne_next_unordered_match(SpanEnum *self)
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  SpanEnum *se, *min_se = NULL;
+  int i;
+  int max_end, end, min_start, start, doc;
+  int lengths_sum;
+
+  while (true) {
+
+    max_end = 0;
+    min_start = INT_MAX;
+    lengths_sum = 0;
+
+    for (i = 0; i < sne->s_cnt; i++) {
+      se = sne->span_enums[i];
+      if ((end=se->end(se)) > max_end) max_end = end;
+      if ((start=se->start(se)) < min_start) {
+        min_start = start;
+        min_se = se;
+        sne->current = i; /* current should point to the minimum span */
+      }
+      lengths_sum += end - start;
+    }
+
+    if ((max_end - min_start - lengths_sum) <= sne->slop) {
+      /* we have a match */
+      sne->start = min_start;
+      sne->end = max_end;
+      sne->doc = min_se->doc(min_se);
+      return true;
+    }
+
+    /* increment the minimum span_enum and try again */
+    doc = min_se->doc(min_se);
+    if (!min_se->next(min_se)) return false;
+    if (doc < min_se->doc(min_se)) {
+      if (!sne_goto_next_doc(sne)) return false;
+    }
+  }
+}
+
+bool sne_next_ordered_match(SpanEnum *self)
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  SpanEnum *se;
+  int i;
+  int prev_doc, prev_start, prev_end;
+  int doc=0, start=0, end=0;
+  int lengths_sum;
+
+  while (true) {
+    se = sne->span_enums[0];
+
+    prev_doc = se->doc(se);
+    sne->start = prev_start = se->start(se);
+    prev_end = se->end(se);
+
+    i = 1;
+    lengths_sum = prev_end - prev_start;
+
+    while (i < sne->s_cnt) {
+      se = sne->span_enums[i];
+      doc = se->doc(se);
+      start = se->start(se);
+      end = se->end(se);
+      while ((doc == prev_doc) && ((start < prev_start) ||
+           ((start == prev_start) && (end < prev_end)))) {
+        if (!se->next(se)) return false;
+        doc = se->doc(se);
+        start = se->start(se);
+        end = se->end(se);
+      }
+      if (doc != prev_doc) {
+        sne->current = i;
+        if (!sne_goto_next_doc(sne)) return false;
+        break;
+      }
+      i++;
+      lengths_sum += end - start;
+      prev_doc = doc;
+      prev_start = start;
+      prev_end = end;
+    }
+    if (i == sne->s_cnt) {
+      if ((end - sne->start - lengths_sum) <= sne->slop) {
+        /* we have a match */
+        sne->end = end;
+        sne->doc = doc;
+
+        /* the minimum span is always the first span so it needs to be
+         * incremented next time around */
+        sne->current = 0;
+        return true;
+
+      } else {
+        se = sne->span_enums[0];
+        if (!se->next(se)) return false;
+        if (se->doc(se) != prev_doc) {
+          sne->current = 0;
+          if (!sne_goto_next_doc(sne)) return false;
+        }
+      }
+    }
+  }
+}
+  
+bool sne_next_match(SpanEnum *self)
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  SpanEnum *se_curr, *se_next;
+
+  if (!sne->first_time) {
+    if (!sne_init(sne)) return false;
+    sne->first_time = false;
+  }
+  se_curr = sne->span_enums[sne->current];
+  se_next = sne->span_enums[(sne->current+1)%sne->s_cnt];
+  if (se_curr->doc(se_curr) > se_next->doc(se_next)) {
+    if (!sne_goto_next_doc(sne)) return false;
+  }
+
+  if (sne->in_order) {
+    return sne_next_ordered_match(self);
+  } else {
+    return sne_next_unordered_match(self);
+  }
+}
+
+bool spanne_next(SpanEnum *self)
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  SpanEnum *se;
+
+  se = sne->span_enums[sne->current];
+  if (!se->next(se)) return false;
+
+  return sne_next_match(self);
+}
+
+bool spanne_skip_to(SpanEnum *self, int target)
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  SpanEnum *se;
+
+  se = sne->span_enums[sne->current];
+  if (!se->skip_to(se, target)) return false;
+
+  return sne_next_match(self);
+}
+
+#define GET_TOP_SNE SpanNearEnum *sne = (SpanNearEnum *)self->data;
+
+int  spanne_doc(SpanEnum *self)
+{
+  GET_TOP_SNE;
+  return sne->doc;
+}
+
+int  spanne_start(SpanEnum *self)
+{
+  GET_TOP_SNE;
+  return sne->start;
+}
+
+int  spanne_end(SpanEnum *self)
+{
+  GET_TOP_SNE;
+  return sne->end;
+}
+
+char *spanne_to_s(SpanEnum *self) 
+{
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  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);
+  char *str = ALLOC_N(char, len + 80);
+
+  if (sne->first_time) {
+    sprintf(doc_str, "START");
+  } else {
+    sprintf(doc_str, "%d:%d-%d", self->doc(self),
+          self->start(self), self->end(self));
+  }
+  sprintf("SpanNearEnum(%s)@%s", query_str, doc_str);
+  free(query_str);
+  return str;
+}
+
+void spanne_destroy(void *p)
+{
+  SpanEnum *self = (SpanEnum *)p, *se;
+  SpanNearEnum *sne = (SpanNearEnum *)self->data;
+  int i;
+  for (i = 0; i < sne->s_cnt; i++) {
+    se = sne->span_enums[i];
+    se->destroy(se);
+  }
+  free(sne->span_enums);
+  free(sne);
+  free(self);
+}
+
+SpanEnum *spanne_create(Query *query, IndexReader *ir)
+{
+  Query *clause;
+  SpanEnum *self = ALLOC(SpanEnum);
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)query->data)->data;
+  SpanNearEnum *sne = ALLOC(SpanNearEnum);
+  int i;
+  sne->first_time = true;
+  sne->in_order = snq->in_order;
+  sne->slop = snq->slop;
+  sne->s_cnt = snq->c_cnt;
+  sne->span_enums = ALLOC_N(SpanEnum *, sne->s_cnt);
+  for (i = 0; i < sne->s_cnt; i++) {
+    clause = snq->clauses[i];
+    sne->span_enums[i] = ((SpanQuery *)clause->data)->get_spans(clause, ir);
+  }
+  sne->current = 0;
+  
+  sne->doc = -1;
+  sne->start = -1;
+  sne->end = -1;
+
+  self->data = sne;
+
+  self->query = query;
+  self->next = &spanne_next;
+  self->skip_to = &spanne_skip_to;
+  self->doc = &spanne_doc;
+  self->start = &spanne_start;
+  self->end = &spanne_end;
+  self->destroy = &spanne_destroy;
+  self->to_s = &spanne_to_s;
+
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanNotEnum
+ *
+ *****************************************************************************/
+
+bool spanxe_next(SpanEnum *self)
+{
+  SpanNotEnum *sxe = (SpanNotEnum *)(self->data);
+  SpanEnum *inc = sxe->inc, *exc = sxe->exc;
+  if (sxe->more_inc) {                       // move to next incl
+    sxe->more_inc = inc->next(inc);
+  }
+
+  while (sxe->more_inc && sxe->more_exc) {
+    if (inc->doc(inc) > exc->doc(exc)) {     // skip excl
+      sxe->more_exc = exc->skip_to(exc, inc->doc(inc));
+    }
+
+    while (sxe->more_exc &&                  // while excl is before
+           (inc->doc(inc) == exc->doc(exc)) &&
+           (exc->end(exc) <= inc->start(inc))) {
+      sxe->more_exc = exc->next(exc);        // increment excl
+    }
+
+    if (! sxe->more_exc ||                   // if no intersection
+        (inc->doc(inc) != exc->doc(exc)) ||
+        inc->end(inc) <= exc->start(exc)) {
+      break;                                 // we found a match
+    }
+
+    sxe->more_inc = inc->next(inc);          // intersected: keep scanning
+  }
+  return sxe->more_inc;
+}
+
+bool spanxe_skip_to(SpanEnum *self, int target)
+{
+  SpanNotEnum *sxe = (SpanNotEnum *)(self->data);
+  SpanEnum *inc = sxe->inc, *exc = sxe->exc;
+  int doc;
+
+  if (sxe->more_inc) {                       // move to next incl
+    if (!(sxe->more_inc=sxe->inc->skip_to(sxe->inc, target))) return false;
+  }
+
+  if (sxe->more_inc && ((doc=inc->doc(inc)) > exc->doc(exc))) {
+    sxe->more_exc = exc->skip_to(exc, doc);
+  }
+
+  while (sxe->more_exc &&                    // while excl is before
+         inc->doc(inc) == exc->doc(exc) &&
+         exc->end(exc) <= inc->start(inc)) {
+    sxe->more_exc = exc->next(exc);          // increment excl
+  }
+
+  if (!sxe->more_exc ||                      // if no intersection
+        inc->doc(inc) != exc->doc(exc) ||
+        inc->end(inc) <= exc->start(exc)) {
+    return true;                             // we found a match
+  }
+
+  return spanxe_next(self);                  // scan to next match
+}
+
+int  spanxe_doc(SpanEnum *self)
+{
+  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
+  return inc->doc(inc);
+}
+
+int  spanxe_start(SpanEnum *self)
+{
+  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
+  return inc->start(inc);
+}
+
+int  spanxe_end(SpanEnum *self)
+{
+  SpanEnum *inc = ((SpanNotEnum *)(self->data))->inc;
+  return inc->end(inc);
+}
+
+char *spanxe_to_s(SpanEnum *self) 
+{
+  char *field = ((SpanQuery *)self->query->data)->field;
+  char *query_str = self->query->to_s(self->query, field);
+  char *res = epstrdup("SpanNotEnum(%s)", strlen(query_str), query_str);
+  free(query_str);
+  return res;
+}
+
+void spanxe_destroy(void *p)
+{
+  SpanEnum *self = (SpanEnum *)p;
+  SpanNotEnum *sxe = (SpanNotEnum *)self->data;
+  sxe->inc->destroy(sxe->inc);
+  sxe->exc->destroy(sxe->exc);
+  free(sxe);
+  free(self);
+}
+
+SpanEnum *spanxe_create(Query *query, IndexReader *ir)
+{
+  SpanEnum *self = ALLOC(SpanEnum);
+  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)query->data)->data;
+
+  SpanNotEnum *sxe = self->data = ALLOC(SpanNotEnum);
+  sxe->inc = ((SpanQuery *)sxq->inc->data)->get_spans(sxq->inc, ir);
+  sxe->exc = ((SpanQuery *)sxq->exc->data)->get_spans(sxq->exc, ir);
+  sxe->more_inc = true;
+  sxe->more_exc = sxe->exc->next(sxe->exc);
+
+  self->query = query;
+  self->next = &spanxe_next;
+  self->skip_to = &spanxe_skip_to;
+  self->doc = &spanxe_doc;
+  self->start = &spanxe_start;
+  self->end = &spanxe_end;
+  self->destroy = &spanxe_destroy;
+  self->to_s = &spanxe_to_s;
+
+  return self;
+}
+/*****************************************************************************
+ *
+ * SpanQuery
+ *
+ *****************************************************************************/
+
+void spanq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  SpanQuery *sq = (SpanQuery *)self->data;
+  free(sq);
+  q_destroy(self);
+}
+
+/*****************************************************************************
+ *
+ * SpanTermQuery
+ *
+ *****************************************************************************/
+
+char *spantq_to_s(Query *self, char *field)
+{
+  Term *term = (Term *)((SpanQuery *)self->data)->data;
+  char *term_str, *res;
+  if (field == term->field) {
+    term_str = estrdup(term->text);
+  } else {
+    term_str = term_to_s(term);
+  }
+  res = epstrdup("span_term(%s)", strlen(term_str), term_str);
+  free(term_str);
+  return res;
+}
+
+void spantq_destroy(void *p)
+{
+  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);
+}
+
+void spantq_extract_terms(Query *self, Array *terms)
+{
+  Term *term = (Term *)((SpanQuery *)self->data)->data;
+  ary_append(terms, term);
+}
+
+Array *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));
+  return terms;
+}
+
+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->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;
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanFirstQuery
+ *
+ *****************************************************************************/
+
+char *spanfq_to_s(Query *self, char *field)
+{
+  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
+  Query *match = sfq->match;
+  char *q_str = match->to_s(match, field);
+  char *res = epstrdup("span_first(%s, %d)", strlen(q_str) + 20, q_str, sfq->end);
+  free(q_str);
+  return res;
+}
+
+void spanfq_extract_terms(Query *self, Array *terms)
+{
+  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
+  sfq->match->extract_terms(sfq->match, terms);
+}
+
+Array *spanfq_get_terms(Query *self)
+{
+  SpanFirstQuery *sfq = (SpanFirstQuery *)((SpanQuery *)self->data)->data;
+  SpanQuery *match_sq = (SpanQuery *)sfq->match->data;
+  return match_sq->get_terms(sfq->match);
+}
+
+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 */
+  }
+
+  if (clone != NULL) {
+    if (self->rewritten) self->rewritten->destroy(self->rewritten);
+    return self->rewritten = clone; /* some clauses rewrote */
+  } else {
+    return self;                    /* no clauses rewrote */
+  }
+}
+
+void spanfq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  SpanQuery *sq = (SpanQuery *)self->data;
+  SpanFirstQuery *sfq = (SpanFirstQuery *)sq->data;
+  if (self->destroy_all) sfq->match->destroy(sfq->match);
+  free(sfq);
+  free(sq);
+  q_destroy(self);
+}
+
+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;
+  sq->data = sfq;
+
+  sq->get_spans = &spanfe_create;
+  sq->get_terms = &spanfq_get_terms;
+  sq->field = ((SpanQuery *)match->data)->field;
+
+  self->type = SPAN_FIRST_QUERY;
+  self->data = sq;
+  self->create_weight = &spanw_create;
+  self->extract_terms = &spanfq_extract_terms;
+  self->rewrite = &spanfq_rewrite;
+  self->to_s = &spanfq_to_s;
+  self->destroy = &spanfq_destroy;
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanOrQuery
+ *
+ *****************************************************************************/
+
+char *spanoq_to_s(Query *self, char *field)
+{
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+  char *res = estrdup("span_or["), *q_str;
+  Query *clause;
+  int i;
+  for (i = 0; i < soq->c_cnt; i++) {
+    clause = soq->clauses[i];
+    q_str = clause->to_s(clause, field);
+    REALLOC_N(res, char, strlen(res) + strlen(q_str) + 10);
+    if (i > 0) strcat(res, ", ");
+    strcat(res, q_str);
+    free(q_str);
+  }
+  strcat(res, "]");
+
+  return res;
+}
+
+void spanoq_extract_terms(Query *self, Array *terms)
+{
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+  Query *clause;
+  int i;
+  for (i = 0; i < soq->c_cnt; i++) {
+    clause = soq->clauses[i];
+    clause->extract_terms(clause, terms);
+  }
+}
+
+Array *spanoq_get_terms(Query *self)
+{
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+  Array *terms = ary_create(soq->c_cnt, NULL);
+  Query *clause;
+  int i;
+  for (i = 0; i < soq->c_cnt; i++) {
+    clause = soq->clauses[i];
+    clause->extract_terms(clause, terms);
+  }
+
+  return terms;
+}
+
+SpanEnum *spanoq_get_spans(Query *self, IndexReader *ir)
+{
+  SpanOrQuery *soq = (SpanOrQuery *)((SpanQuery *)self->data)->data;
+  Query *q;
+  if (soq->c_cnt == 1) {
+    q = soq->clauses[0];
+    return ((SpanQuery *)q->data)->get_spans(q, ir);
+  }
+
+  return spanoe_create(self, 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;
+  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 (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;
+  }
+}
+
+void spanoq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  SpanQuery *sq = (SpanQuery *)self->data;
+  SpanOrQuery *soq = (SpanOrQuery *)sq->data;
+
+  if (self->destroy_all) {
+    Query *clause;
+    int i;
+    for (i = 0; i < soq->c_cnt; i++) {
+      clause = soq->clauses[i];
+      clause->destroy(clause);
+    }
+    free(soq->clauses);
+  }
+
+
+  free(soq);
+  free(sq);
+  q_destroy(self);
+}
+
+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;
+  sq->data = soq;
+
+  sq->get_spans = &spanoq_get_spans;
+  sq->get_terms = &spanoq_get_terms;
+  sq->field = ((SpanQuery *)clauses[0]->data)->field;
+
+  self->type = SPAN_OR_QUERY;
+  self->data = sq;
+  self->create_weight = &spanw_create;
+  self->extract_terms = &spanoq_extract_terms;
+  self->rewrite = &spanoq_rewrite;
+  self->to_s = &spanoq_to_s;
+  self->destroy = &spanoq_destroy;
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanNearQuery
+ *
+ *****************************************************************************/
+
+char *spannq_to_s(Query *self, char *field)
+{
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+  char *res = estrdup("span_near(["), *q_str;
+  Query *clause;
+  int i;
+  for (i = 0; i < snq->c_cnt; i++) {
+    clause = snq->clauses[i];
+    q_str = clause->to_s(clause, field);
+    REALLOC_N(res, char, strlen(res) + strlen(q_str) + 10);
+    if (i > 0) strcat(res, ", ");
+    strcat(res, q_str);
+    free(q_str);
+  }
+  REALLOC_N(res, char, strlen(res) + 40);
+  sprintf(res + strlen(res), "], %d, %s)", snq->slop,
+      snq->in_order ? "Ordered" : "Unordered");
+
+  return res;
+}
+
+void spannq_extract_terms(Query *self, Array *terms)
+{
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+  Query *clause;
+  int i;
+  for (i = 0; i < snq->c_cnt; i++) {
+    clause = snq->clauses[i];
+    clause->extract_terms(clause, terms);
+  }
+}
+
+Array *spannq_get_terms(Query *self)
+{
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+  Array *terms = ary_create(snq->c_cnt, NULL);
+  Query *clause;
+  int i;
+  for (i = 0; i < snq->c_cnt; i++) {
+    clause = snq->clauses[i];
+    clause->extract_terms(clause, terms);
+  }
+
+  return terms;
+}
+
+SpanEnum *spannq_get_spans(Query *self, IndexReader *ir)
+{
+  SpanNearQuery *snq = (SpanNearQuery *)((SpanQuery *)self->data)->data;
+  Query *q;
+
+  if (snq->c_cnt == 1) {
+    q = snq->clauses[0];
+    return ((SpanQuery *)q->data)->get_spans(q, ir);
+  }
+
+  return spanne_create(self, 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 (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;
+  }
+}
+
+void spannq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  SpanQuery *sq = (SpanQuery *)self->data;
+  SpanNearQuery *snq = (SpanNearQuery *)sq->data;
+
+  if (self->destroy_all) {
+    Query *clause;
+    int i;
+    for (i = 0; i < snq->c_cnt; i++) {
+      clause = snq->clauses[i];
+      clause->destroy(clause);
+    }
+    free(snq->clauses);
+  }
+
+
+  free(snq);
+  free(sq);
+  q_destroy(self);
+}
+
+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;
+  snq->slop = slop;
+  snq->in_order = in_order;
+  sq->data = snq;
+
+  sq->get_spans = &spannq_get_spans;
+  sq->get_terms = &spannq_get_terms;
+
+  sq->field = ((SpanQuery *)clauses[0]->data)->field;
+
+  self->type = SPAN_NEAR_QUERY;
+  self->data = sq;
+  self->create_weight = &spanw_create;
+  self->extract_terms = &spannq_extract_terms;
+  self->rewrite = &spannq_rewrite;
+  self->to_s = &spannq_to_s;
+  self->destroy = &spannq_destroy;
+  return self;
+}
+
+/*****************************************************************************
+ *
+ * SpanNotQuery
+ *
+ *****************************************************************************/
+
+char *spanxq_to_s(Query *self, char *field)
+{
+  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
+  char *inc_s = sxq->inc->to_s(sxq->inc, field);
+  char *exc_s = sxq->exc->to_s(sxq->exc, field);
+  char *res = epstrdup("span_not(inc:<%s>, exc:<%s>)",
+      strlen(inc_s) + strlen(exc_s), inc_s, exc_s);
+  
+  free(inc_s);
+  free(exc_s);
+  return res;
+}
+
+void spanxq_extract_terms(Query *self, Array *terms)
+{
+  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
+  sxq->inc->extract_terms(sxq->inc, terms);
+}
+
+Array *spanxq_get_terms(Query *self)
+{
+  SpanNotQuery *sxq = (SpanNotQuery *)((SpanQuery *)self->data)->data;
+  Array *terms = ary_create(1, NULL);
+  sxq->inc->extract_terms(sxq->inc, terms);
+  return terms;
+}
+
+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;
+  }
+
+  if (clone != NULL) {
+    if (self->rewritten) self->rewritten->destroy(self->rewritten);
+    return self->rewritten = clone; /* some clauses rewrote */
+  } else {
+    return self; /* no clauses rewrote */
+  }
+}
+
+void spanxq_destroy(void *p)
+{
+  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);
+  }
+
+  free(sxq);
+  free(sq);
+  q_destroy(self);
+}
+
+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;
+  sq->data = sxq;
+
+  sq->get_spans = &spanxe_create;
+  sq->get_terms = &spanxq_get_terms;
+  sq->field = ((SpanQuery *)inc->data)->field;
+
+  self->type = SPAN_NOT_QUERY;
+  self->data = sq;
+  self->create_weight = &spanw_create;
+  self->extract_terms = &spanxq_extract_terms;
+  self->rewrite = &spanxq_rewrite;
+  self->to_s = &spanxq_to_s;
+  self->destroy = &spanxq_destroy;
+  return self;
+}
+
+/***************************************************************************
+ *
+ * SpanScorer
+ *
+ ***************************************************************************/
+
+float spansc_score(Scorer *self)
+{
+  SpanScorer *spansc = (SpanScorer *)self->data;
+  float raw = sim_tf(spansc->sim, spansc->freq) * spansc->value;
+
+  /* normalize */
+  return raw * sim_decode_norm(self->similarity, spansc->norms[self->doc]);
+}
+
+bool spansc_next(Scorer *self)
+{
+  SpanScorer *spansc = (SpanScorer *)self->data;
+  SpanEnum *se = spansc->spans;
+  int match_length;
+
+  if (spansc->first_time) {
+    spansc->more = se->next(se);
+    spansc->first_time = false;
+  }
+
+  if (!spansc->more) return false;
+
+  spansc->freq = 0.0;
+  self->doc = se->doc(se);
+
+  while (spansc->more && (self->doc == se->doc(se))) {
+    match_length = se->end(se) - se->start(se);
+    spansc->freq += sim_sloppy_freq(spansc->sim, match_length);
+    spansc->more = se->next(se);
+  }
+
+  return (spansc->more || (spansc->freq != 0.0));
+}
+
+bool spansc_skip_to(Scorer *self, int target)
+{
+  SpanScorer *spansc = (SpanScorer *)self->data;
+  SpanEnum *se = spansc->spans;
+
+  spansc->more = se->skip_to(se, target);
+
+  if (!spansc->more) return false;
+
+  spansc->freq = 0.0;
+  self->doc = se->doc(se);
+
+  while (spansc->more && (se->doc(se) == target)) {
+    spansc->freq += sim_sloppy_freq(spansc->sim, se->end(se) - se->start(se));
+    spansc->more = se->next(se);
+  }
+
+  return (spansc->more || (spansc->freq != 0.0));
+}
+
+Explanation *spansc_explain(Scorer *self, int target)
+{
+  SpanScorer *spansc = (SpanScorer *)self->data;
+  float phrase_freq;
+  self->skip_to(self, target);
+  phrase_freq = (self->doc == target) ? spansc->freq : 0.0;
+
+  Explanation *tf_explanation = expl_create(sim_tf(self->similarity, phrase_freq),
+      epstrdup("tf(phrase_freq(%#.5g)", 32, phrase_freq));
+
+  return tf_explanation;
+}
+
+void spansc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  SpanScorer *spansc = (SpanScorer *)self->data;
+  if (spansc->spans) spansc->spans->destroy(spansc->spans);
+  //free(spansc->norms);
+  scorer_destroy(p);
+}
+
+Scorer *spansc_create(Weight *weight, IndexReader *ir)
+{
+  Scorer *self = scorer_create(weight->similarity);
+  SpanScorer *spansc = ALLOC(SpanScorer);
+  SpanQuery *spanq = (SpanQuery *)weight->query->data;
+  ZEROSET(spansc, SpanScorer, 1);
+  spansc->first_time = true;
+  spansc->more = true;
+  spansc->spans = spanq->get_spans(weight->query, ir);
+  spansc->sim = weight->similarity;
+  spansc->norms = ir->get_norms(ir, spanq->field);
+  spansc->weight = weight;
+  spansc->value = weight->value;
+  spansc->freq = 0.0;
+
+  self->data = spansc;
+
+  self->score = &spansc_score;
+  self->next = &spansc_next;
+  self->skip_to = &spansc_skip_to;
+  self->explain = &spansc_explain;
+  self->destroy = &spansc_destroy;
+  return self;
+}