ferret 0.11.6 → 0.11.8.4

data/ext/q_span.c

@@ -2,6 +2,8 @@
 #include <limits.h>
 #include "search.h"
 #include "hashset.h"
+#include "symbol.h"
+#include "internal.h"
 
 #define CLAUSE_INIT_CAPA 4
 
@@ -19,12 +21,12 @@
 
 static unsigned long spanq_hash(Query *self)
 {
-    return str_hash(SpQ(self)->field);
+    return SpQ(self)->field ? sym_hash(SpQ(self)->field) : 0;
 }
 
 static int spanq_eq(Query *self, Query *o)
 {
-    return strcmp(SpQ(self)->field, SpQ(o)->field) == 0;
+    return SpQ(self)->field == SpQ(o)->field;
 }
 
 static void spanq_destroy_i(Query *self)
@@ -35,15 +37,14 @@ static void spanq_destroy_i(Query *self)
 static MatchVector *mv_to_term_mv(MatchVector *term_mv, MatchVector *full_mv,
                                   HashSet *terms, TermVector *tv)
 {
-    int i;
-    for (i = 0; i < terms->size; i++) {
-        char *term = (char *)terms->elems[i];
+    HashSetEntry *hse;
+    for (hse = terms->first; hse; hse = hse->next) {
+        char *term = (char *)hse->elem;
         TVTerm *tv_term = tv_get_tv_term(tv, term);
         if (tv_term) {
-            int j;
-            int m_idx = 0;
-            for (j = 0; j < tv_term->freq; j++) {
-                int pos = tv_term->positions[j];
+            int i, m_idx = 0;
+            for (i = 0; i < tv_term->freq; i++) {
+                int pos = tv_term->positions[i];
                 for (; m_idx < full_mv->size; m_idx++) {
                     if (pos <= full_mv->matches[m_idx].end) {
                         if (pos >= full_mv->matches[m_idx].start) {
@@ -134,29 +135,31 @@ static int tv_tde_doc_num(TermDocEnum *tde)
 static TermDocEnum *spanq_ir_term_positions(IndexReader *ir)
 {
     TVTermDocEnum *tv_tde = ALLOC(TVTermDocEnum);
-    TermDocEnum *tde = (TermDocEnum *)tv_tde;
-    tv_tde->tv = (TermVector *)ir->store;
-    tde->seek           = &tv_tde_seek;
-    tde->doc_num        = &tv_tde_doc_num;
-    tde->freq           = &tv_tde_freq;
-    tde->next           = &tv_tde_next;
-    tde->skip_to        = &tv_tde_skip_to;
-    tde->next_position  = &tv_tde_next_position;
-    tde->close          = (void (*)(TermDocEnum *tde))&free;
-    
+    TermDocEnum *tde      = (TermDocEnum *)tv_tde;
+    tv_tde->tv            = (TermVector *)ir->store;
+    tde->seek             = &tv_tde_seek;
+    tde->doc_num          = &tv_tde_doc_num;
+    tde->freq             = &tv_tde_freq;
+    tde->next             = &tv_tde_next;
+    tde->skip_to          = &tv_tde_skip_to;
+    tde->next_position    = &tv_tde_next_position;
+    tde->close            = (void (*)(TermDocEnum *tde))&free;
+
     return tde;
 }
 
 static MatchVector *spanq_get_matchv_i(Query *self, MatchVector *mv,
                                        TermVector *tv)
 {
-    if (strcmp(SpQ(self)->field, tv->field) == 0) {
+    if (SpQ(self)->field == tv->field) {
         SpanEnum *sp_enum;
         IndexReader *ir = ALLOC(IndexReader);
         MatchVector *full_mv = matchv_new();
         HashSet *terms = SpQ(self)->get_terms(self);
-        ir->fis = fis_new(0, 0, 0);
-        fis_add_field(ir->fis, fi_new(tv->field, 0, 0, 0));
+        /* FIXME What is going on here? Need to document this! */
+        ir->fis = fis_new(STORE_NO, INDEX_NO, TERM_VECTOR_NO);
+        fis_add_field(ir->fis,
+                      fi_new(tv->field, STORE_NO, INDEX_NO, TERM_VECTOR_NO));
         ir->store = (Store *)tv;
         ir->term_positions = &spanq_ir_term_positions;
         sp_enum = SpQ(self)->get_spans(self, ir);
@@ -166,7 +169,7 @@ static MatchVector *spanq_get_matchv_i(Query *self, MatchVector *mv,
                        sp_enum->end(sp_enum) - 1);
         }
         sp_enum->destroy(sp_enum);
-        
+
         fis_deref(ir->fis);
         free(ir);
 
@@ -226,11 +229,11 @@ static bool spansc_next(Scorer *self)
     spansc->freq = 0.0;
     self->doc = se->doc(se);
 
-    while (spansc->more && (self->doc == se->doc(se))) {
+    do {
         match_length = se->end(se) - se->start(se);
         spansc->freq += sim_sloppy_freq(spansc->sim, match_length);
         spansc->more = se->next(se);
-    }
+    } while (spansc->more && (self->doc == se->doc(se)));
 
     return (spansc->more || (spansc->freq != 0.0));
 }
@@ -241,7 +244,6 @@ static bool spansc_skip_to(Scorer *self, int target)
     SpanEnum *se = spansc->spans;
 
     spansc->more = se->skip_to(se, target);
-
     if (!spansc->more) {
         return false;
     }
@@ -252,6 +254,9 @@ static bool spansc_skip_to(Scorer *self, int target)
     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);
+        if (spansc->first_time) {
+            spansc->first_time = false;
+        }
     }
 
     return (spansc->more || (spansc->freq != 0.0));
@@ -280,7 +285,7 @@ static void spansc_destroy(Scorer *self)
     scorer_destroy_i(self);
 }
 
-Scorer *spansc_new(Weight *weight, IndexReader *ir)
+static Scorer *spansc_new(Weight *weight, IndexReader *ir)
 {
     Scorer *self = NULL;
     const int field_num = fis_get_field_num(ir->fis, SpQ(weight->query)->field);
@@ -349,9 +354,12 @@ static bool spante_skip_to(SpanEnum *self, int target)
     TermDocEnum *tde = ste->positions;
 
     /* are we already at the correct position? */
+    /* FIXME: perhaps this the the better solution but currently it ->skip_to
+     * does a ->next not matter what
     if (ste->doc >= target) {
         return true;
     }
+    */
 
     if (! tde->skip_to(tde, target)) {
         ste->doc = INT_MAX;
@@ -382,10 +390,9 @@ static int spante_end(SpanEnum *self)
     return SpTEn(self)->position + 1;
 }
 
-static char *spante_to_s(SpanEnum *self) 
+static char *spante_to_s(SpanEnum *self)
 {
-    char *field = SpQ(self->query)->field;
-    char *query_str = self->query->to_s(self->query, field);
+    char *query_str = self->query->to_s(self->query, NULL);
     char pos_str[20];
     size_t len = strlen(query_str);
     int pos;
@@ -403,7 +410,7 @@ static char *spante_to_s(SpanEnum *self)
             sprintf(pos_str, "%d", self->doc(self) - pos);
         }
     }
-    sprintf("SpanTermEnum(%s)@%s", query_str, pos_str);
+    sprintf(str, "SpanTermEnum(%s)@%s", query_str, pos_str);
     free(query_str);
     return str;
 }
@@ -418,10 +425,10 @@ static void spante_destroy(SpanEnum *self)
 static SpanEnum *spante_new(Query *query, IndexReader *ir)
 {
     char *term = SpTQ(query)->term;
-    char *field = SpQ(query)->field;
-    SpanEnum *self = (SpanEnum *)emalloc(sizeof(SpanTermEnum));
+    SpanEnum *self = (SpanEnum *)ALLOC(SpanTermEnum);
 
-    SpTEn(self)->positions  = ir_term_positions_for(ir, field, term);
+    SpTEn(self)->positions  = ir_term_positions_for(ir, SpQ(query)->field,
+                                                    term);
     SpTEn(self)->position   = -1;
     SpTEn(self)->doc        = -1;
     SpTEn(self)->count      = 0;
@@ -531,7 +538,7 @@ static bool spanmte_next(SpanEnum *self)
         }
         mte->tpew_pq = tpew_pq;
     }
-    
+
     tpew = (TermPosEnumWrapper *)pq_top(tpew_pq);
     if (tpew == NULL) {
         return false;
@@ -612,8 +619,7 @@ static void spanmte_destroy(SpanEnum *self)
 
 static SpanEnum *spanmte_new(Query *query, IndexReader *ir)
 {
-    char *field = SpQ(query)->field;
-    SpanEnum *self = (SpanEnum *)emalloc(sizeof(SpanMultiTermEnum));
+    SpanEnum *self = (SpanEnum *)ALLOC(SpanMultiTermEnum);
     SpanMultiTermEnum *smte = SpMTEn(self);
     SpanMultiTermQuery *smtq = SpMTQ(query);
     int i;
@@ -622,7 +628,8 @@ static SpanEnum *spanmte_new(Query *query, IndexReader *ir)
     smte->tpews = ALLOC_N(TermPosEnumWrapper *, smtq->term_cnt);
     for (i = 0; i < smtq->term_cnt; i++) {
         char *term = smtq->terms[i];
-        smte->tpews[i] = tpew_new(term, ir_term_positions_for(ir, field, term));
+        smte->tpews[i] = tpew_new(term,
+            ir_term_positions_for(ir, SpQ(query)->field, term));
     }
     smte->tpew_cnt          = smtq->term_cnt;
     smte->tpew_pq           = NULL;
@@ -681,7 +688,7 @@ static bool spanfe_skip_to(SpanEnum *self, int target)
         return true;
     }
 
-    return sub_enum->next(sub_enum);        /* scan to next match */
+    return spanfe_next(self);        /* scan to next match */
 }
 
 static int spanfe_doc(SpanEnum *self)
@@ -702,10 +709,9 @@ static int spanfe_end(SpanEnum *self)
     return sub_enum->end(sub_enum);
 }
 
-static char *spanfe_to_s(SpanEnum *self) 
+static char *spanfe_to_s(SpanEnum *self)
 {
-    char *field = SpQ(self->query)->field;
-    char *query_str = self->query->to_s(self->query, field);
+    char *query_str = self->query->to_s(self->query, NULL);
     char *res = strfmt("SpanFirstEnum(%s)", query_str);
     free(query_str);
     return res;
@@ -720,7 +726,7 @@ static void spanfe_destroy(SpanEnum *self)
 
 static SpanEnum *spanfe_new(Query *query, IndexReader *ir)
 {
-    SpanEnum *self          = (SpanEnum *)emalloc(sizeof(SpanFirstEnum));
+    SpanEnum *self          = (SpanEnum *)ALLOC(SpanFirstEnum);
     SpanFirstQuery *sfq     = SpFQ(query);
 
     SpFEn(self)->sub_enum   = SpQ(sfq->match)->get_spans(sfq->match, ir);
@@ -822,7 +828,8 @@ static bool spanoe_skip_to(SpanEnum *self, int target)
     }
     else {
         while ((soe->queue->size != 0) &&
-               ((se = (SpanEnum *)pq_top(soe->queue))->doc(se) < target)) {
+               ((se = (SpanEnum *)pq_top(soe->queue)) != NULL) &&
+               (se->doc(se) < target)) {
             if (se->skip_to(se, target)) {
                 pq_down(soe->queue);
             }
@@ -855,11 +862,10 @@ static int spanoe_end(SpanEnum *self)
     return se->end(se);
 }
 
-static char *spanoe_to_s(SpanEnum *self) 
+static char *spanoe_to_s(SpanEnum *self)
 {
     SpanOrEnum *soe = SpOEn(self);
-    char *field = SpQ(self->query)->field;
-    char *query_str = self->query->to_s(self->query, field);
+    char *query_str = self->query->to_s(self->query, NULL);
     char doc_str[62];
     size_t len = strlen(query_str);
     char *str = ALLOC_N(char, len + 80);
@@ -876,7 +882,7 @@ static char *spanoe_to_s(SpanEnum *self)
                     self->start(self), self->end(self));
         }
     }
-    sprintf("SpanOrEnum(%s)@%s", query_str, doc_str);
+    sprintf(str, "SpanOrEnum(%s)@%s", query_str, doc_str);
     free(query_str);
     return str;
 }
@@ -895,10 +901,10 @@ static void spanoe_destroy(SpanEnum *self)
     free(self);
 }
 
-SpanEnum *spanoe_new(Query *query, IndexReader *ir)
+static SpanEnum *spanoe_new(Query *query, IndexReader *ir)
 {
     Query *clause;
-    SpanEnum *self      = (SpanEnum *)emalloc(sizeof(SpanOrEnum));
+    SpanEnum *self      = (SpanEnum *)ALLOC(SpanOrEnum);
     SpanOrQuery *soq    = SpOQ(query);
     int i;
 
@@ -1168,11 +1174,10 @@ static int spanne_end(SpanEnum *self)
     return SpNEn(self)->end;
 }
 
-static char *spanne_to_s(SpanEnum *self) 
+static char *spanne_to_s(SpanEnum *self)
 {
     SpanNearEnum *sne = SpNEn(self);
-    char *field = SpQ(self->query)->field;
-    char *query_str = self->query->to_s(self->query, field);
+    char *query_str = self->query->to_s(self->query, NULL);
     char doc_str[62];
     size_t len = strlen(query_str);
     char *str = ALLOC_N(char, len + 80);
@@ -1184,7 +1189,7 @@ static char *spanne_to_s(SpanEnum *self)
         sprintf(doc_str, "%d:%d-%d", self->doc(self),
                 self->start(self), self->end(self));
     }
-    sprintf("SpanNearEnum(%s)@%s", query_str, doc_str);
+    sprintf(str, "SpanNearEnum(%s)@%s", query_str, doc_str);
     free(query_str);
     return str;
 }
@@ -1206,7 +1211,7 @@ static SpanEnum *spanne_new(Query *query, IndexReader *ir)
 {
     int i;
     Query *clause;
-    SpanEnum *self          = (SpanEnum *)emalloc(sizeof(SpanNearEnum));
+    SpanEnum *self          = (SpanEnum *)ALLOC(SpanNearEnum);
     SpanNearQuery *snq      = SpNQ(query);
 
     SpNEn(self)->first_time = true;
@@ -1333,10 +1338,9 @@ static int spanxe_end(SpanEnum *self)
     return inc->end(inc);
 }
 
-static char *spanxe_to_s(SpanEnum *self) 
+static char *spanxe_to_s(SpanEnum *self)
 {
-    char *field = SpQ(self->query)->field;
-    char *query_str = self->query->to_s(self->query, field);
+    char *query_str = self->query->to_s(self->query, NULL);
     char *res = strfmt("SpanNotEnum(%s)", query_str);
     free(query_str);
     return res;
@@ -1352,7 +1356,7 @@ static void spanxe_destroy(SpanEnum *self)
 
 static SpanEnum *spanxe_new(Query *query, IndexReader *ir)
 {
-    SpanEnum *self      = (SpanEnum *)emalloc(sizeof(SpanNotEnum));
+    SpanEnum *self      = (SpanEnum *)ALLOC(SpanNotEnum);
     SpanNotEnum *sxe    = SpXEn(self);
     SpanNotQuery *sxq   = SpXQ(query);
 
@@ -1399,27 +1403,26 @@ static Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
     uchar *field_norms;
     float field_norm;
     Explanation *field_norm_expl;
+    const char *field = S(SpQ(self->query)->field);
 
     char *query_str;
     HashSet *terms = SpW(self)->terms;
-    char *field = SpQ(self->query)->field;
-    const int field_num = fis_get_field_num(ir->fis, field);
+    const int field_num = fis_get_field_num(ir->fis, SpQ(self->query)->field);
     char *doc_freqs = NULL;
     size_t df_i = 0;
-    int i;
+    HashSetEntry *hse;
 
     if (field_num < 0) {
         return expl_new(0.0, "field \"%s\" does not exist in the index", field);
     }
 
-    query_str = self->query->to_s(self->query, "");
+    query_str = self->query->to_s(self->query, NULL);
 
-    for (i = 0; i < terms->size; i++) {
-        char *term = (char *)terms->elems[i];
+    for (hse = terms->first; hse; hse = hse->next) {
+        char *term = (char *)hse->elem;
         REALLOC_N(doc_freqs, char, df_i + strlen(term) + 23);
-        sprintf(doc_freqs + df_i, "%s=%d, ", term,
-                ir->doc_freq(ir, field_num, term));
-        df_i = strlen(doc_freqs);
+        df_i += sprintf(doc_freqs + df_i, "%s=%d, ", term,
+                        ir->doc_freq(ir, field_num, term));
     }
     /* remove the ',' at the end of the string if it exists */
     if (terms->size > 0) {
@@ -1468,8 +1471,8 @@ static Explanation *spanw_explain(Weight *self, IndexReader *ir, int target)
     expl_add_detail(field_expl, idf_expl2);
 
     field_norms = ir->get_norms(ir, field_num);
-    field_norm = (field_norms 
-                  ? sim_decode_norm(self->similarity, field_norms[target]) 
+    field_norm = (field_norms
+                  ? sim_decode_norm(self->similarity, field_norms[target])
                   : (float)0.0);
     field_norm_expl = expl_new(field_norm, "field_norm(field=%s, doc=%d)",
                                field, target);
@@ -1502,7 +1505,7 @@ static void spanw_destroy(Weight *self)
 
 static Weight *spanw_new(Query *query, Searcher *searcher)
 {
-    int i;
+    HashSetEntry *hse;
     Weight *self        = w_new(SpanWeight, query);
     HashSet *terms      = SpQ(query)->get_terms(query);
 
@@ -1515,10 +1518,10 @@ static Weight *spanw_new(Query *query, Searcher *searcher)
     self->similarity    = query->get_similarity(query, searcher);
 
     self->idf           = 0.0;
-    
-    for (i = terms->size - 1; i >= 0; i--) {
-        self->idf += sim_idf_term(self->similarity, SpQ(query)->field, 
-                                  (char *)terms->elems[i], searcher);
+
+    for (hse = terms->first; hse; hse = hse->next) {
+        self->idf += sim_idf_term(self->similarity, SpQ(query)->field,
+                                  (char *)hse->elem, searcher);
     }
 
     return self;
@@ -1528,20 +1531,19 @@ static Weight *spanw_new(Query *query, Searcher *searcher)
  * SpanTermQuery
  *****************************************************************************/
 
-static char *spantq_to_s(Query *self, const char *field)
+static char *spantq_to_s(Query *self, Symbol default_field)
 {
-    if (field == SpQ(self)->field) {
+    if (default_field && default_field == SpQ(self)->field) {
         return strfmt("span_terms(%s)", SpTQ(self)->term);
     }
     else {
-        return strfmt("span_terms(%s:%s)", SpQ(self)->field, SpTQ(self)->term);
+        return strfmt("span_terms(%s:%s)", S(SpQ(self)->field), SpTQ(self)->term);
     }
 }
 
 static void spantq_destroy_i(Query *self)
 {
     free(SpTQ(self)->term);
-    free(SpQ(self)->field);
     spanq_destroy_i(self);
 }
 
@@ -1567,12 +1569,12 @@ static int spantq_eq(Query *self, Query *o)
     return spanq_eq(self, o) && strcmp(SpTQ(self)->term, SpTQ(o)->term) == 0;
 }
 
-Query *spantq_new(const char *field, const char *term)
+Query *spantq_new(Symbol field, const char *term)
 {
     Query *self             = q_new(SpanTermQuery);
 
     SpTQ(self)->term        = estrdup(term);
-    SpQ(self)->field        = estrdup(field);
+    SpQ(self)->field        = field;
     SpQ(self)->get_spans    = &spante_new;
     SpQ(self)->get_terms    = &spantq_get_terms;
 
@@ -1591,10 +1593,10 @@ Query *spantq_new(const char *field, const char *term)
  * SpanMultiTermQuery
  *****************************************************************************/
 
-static char *spanmtq_to_s(Query *self, const char *field)
+static char *spanmtq_to_s(Query *self, Symbol field)
 {
     char *terms = NULL, *p;
-    int len = 2, i;
+    int len = 3, i;
     SpanMultiTermQuery *smtq = SpMTQ(self);
     for (i = 0; i < smtq->term_cnt; i++) {
         len += strlen(smtq->terms[i]) + 2;
@@ -1602,11 +1604,10 @@ static char *spanmtq_to_s(Query *self, const char *field)
     p = terms = ALLOC_N(char, len);
     *(p++) = '[';
     for (i = 0; i < smtq->term_cnt; i++) {
+        if (i != 0) *(p++) = ',';
         strcpy(p, smtq->terms[i]);
         p += strlen(smtq->terms[i]);
-        *(p++) = ',';
     }
-    if (p > terms) p--;
     *(p++) = ']';
     *p = '\0';
 
@@ -1614,7 +1615,7 @@ static char *spanmtq_to_s(Query *self, const char *field)
         p = strfmt("span_terms(%s)", terms);
     }
     else {
-        p = strfmt("span_terms(%s:%s)", SpQ(self)->field, terms);
+        p = strfmt("span_terms(%s:%s)", S(SpQ(self)->field), terms);
     }
     free(terms);
     return p;
@@ -1628,7 +1629,6 @@ static void spanmtq_destroy_i(Query *self)
         free(smtq->terms[i]);
     }
     free(smtq->terms);
-    free(SpQ(self)->field);
     spanq_destroy_i(self);
 }
 
@@ -1676,7 +1676,7 @@ static int spanmtq_eq(Query *self, Query *o)
     return true;;
 }
 
-Query *spanmtq_new_conf(const char *field, int max_terms)
+Query *spanmtq_new_conf(Symbol field, int max_terms)
 {
     Query *self             = q_new(SpanMultiTermQuery);
 
@@ -1684,7 +1684,7 @@ Query *spanmtq_new_conf(const char *field, int max_terms)
     SpMTQ(self)->term_cnt   = 0;
     SpMTQ(self)->term_capa  = max_terms;
 
-    SpQ(self)->field        = estrdup(field);
+    SpQ(self)->field        = field;
     SpQ(self)->get_spans    = &spanmte_new;
     SpQ(self)->get_terms    = &spanmtq_get_terms;
 
@@ -1700,7 +1700,7 @@ Query *spanmtq_new_conf(const char *field, int max_terms)
     return self;
 }
 
-Query *spanmtq_new(const char *field)
+Query *spanmtq_new(Symbol field)
 {
     return spanmtq_new_conf(field, SPAN_MULTI_TERM_QUERY_CAPA);
 }
@@ -1719,7 +1719,7 @@ void spanmtq_add_term(Query *self, const char *term)
  *
  *****************************************************************************/
 
-static char *spanfq_to_s(Query *self, const char *field)
+static char *spanfq_to_s(Query *self, Symbol field)
 {
     Query *match = SpFQ(self)->match;
     char *q_str = match->to_s(match, field);
@@ -1755,7 +1755,6 @@ static Query *spanfq_rewrite(Query *self, IndexReader *ir)
 static void spanfq_destroy_i(Query *self)
 {
     q_deref(SpFQ(self)->match);
-    free(SpQ(self)->field);
     spanq_destroy_i(self);
 }
 
@@ -1780,7 +1779,7 @@ Query *spanfq_new_nr(Query *match, int end)
     SpFQ(self)->match       = match;
     SpFQ(self)->end         = end;
 
-    SpQ(self)->field        = estrdup(SpQ(match)->field);
+    SpQ(self)->field        = SpQ(match)->field;
     SpQ(self)->get_spans    = &spanfe_new;
     SpQ(self)->get_terms    = &spanfq_get_terms;
 
@@ -1809,7 +1808,7 @@ Query *spanfq_new(Query *match, int end)
  *
  *****************************************************************************/
 
-static char *spanoq_to_s(Query *self, const char *field)
+static char *spanoq_to_s(Query *self, Symbol field)
 {
     int i;
     SpanOrQuery *soq = SpOQ(self);
@@ -1823,16 +1822,16 @@ static char *spanoq_to_s(Query *self, const char *field)
     }
 
     res_p = res = ALLOC_N(char, len);
-    sprintf(res_p, "span_or[ ");
-    res_p += strlen(res_p);
+    res_p += sprintf(res_p, "span_or[");
     for (i = 0; i < soq->c_cnt; i++) {
-        sprintf(res_p, "%s, ", q_strs[i]);
+        if (i != 0) *(res_p++) = ',';
+        res_p += sprintf(res_p, "%s", q_strs[i]);
         free(q_strs[i]);
-        res_p += strlen(res_p);
     }
     free(q_strs);
 
-    sprintf(res_p - 2, " ]");
+    *(res_p)++ = ']';
+    *res_p = 0;
     return res;
 }
 
@@ -1898,7 +1897,6 @@ static void spanoq_destroy_i(Query *self)
         q_deref(clause);
     }
     free(soq->clauses);
-    free(SpQ(self)->field);
 
     spanq_destroy_i(self);
 }
@@ -1942,7 +1940,7 @@ Query *spanoq_new()
     SpOQ(self)->clauses     = ALLOC_N(Query *, CLAUSE_INIT_CAPA);
     SpOQ(self)->c_capa      = CLAUSE_INIT_CAPA;
 
-    SpQ(self)->field        = estrdup((char *)EMPTY_STRING);
+    SpQ(self)->field        = NULL;
     SpQ(self)->get_spans    = &spanoq_get_spans;
     SpQ(self)->get_terms    = &spanoq_get_terms;
 
@@ -1967,13 +1965,12 @@ Query *spanoq_add_clause_nr(Query *self, Query *clause)
               "SpanQuery.", q_get_query_name(clause->type));
     }
     if (curr_index == 0) {
-        free(SpQ(self)->field);
-        SpQ(self)->field = estrdup(SpQ(clause)->field);
+        SpQ(self)->field = SpQ(clause)->field;
     }
-    else if (strcmp(SpQ(self)->field, SpQ(clause)->field) != 0) {
+    else if (SpQ(self)->field != SpQ(clause)->field) {
         RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
               "Attempted to add a SpanQuery with field \"%s\" to a SpanOrQuery "
-              "with field \"%s\"", SpQ(clause)->field, SpQ(self)->field);
+              "with field \"%s\"", S(SpQ(clause)->field), S(SpQ(self)->field));
     }
     if (curr_index >= SpOQ(self)->c_capa) {
         SpOQ(self)->c_capa <<= 1;
@@ -1995,7 +1992,7 @@ Query *spanoq_add_clause(Query *self, Query *clause)
  *
  *****************************************************************************/
 
-static char *spannq_to_s(Query *self, const char *field)
+static char *spannq_to_s(Query *self, Symbol field)
 {
     int i;
     SpanNearQuery *snq = SpNQ(self);
@@ -2009,16 +2006,16 @@ static char *spannq_to_s(Query *self, const char *field)
     }
 
     res_p = res = ALLOC_N(char, len);
-    sprintf(res_p, "span_near[ ");
-    res_p += strlen(res_p);
+    res_p += sprintf(res_p, "span_near[");
     for (i = 0; i < snq->c_cnt; i++) {
-        sprintf(res_p, "%s, ", q_strs[i]);
+        if (i != 0) *(res_p)++ = ',';
+        res_p += sprintf(res_p, "%s", q_strs[i]);
         free(q_strs[i]);
-        res_p += strlen(res_p);
     }
     free(q_strs);
 
-    sprintf(res_p - 2, " ]");
+    *(res_p++) = ']';
+    *res_p = 0;
     return res;
 }
 
@@ -2083,7 +2080,6 @@ static void spannq_destroy(Query *self)
         q_deref(clause);
     }
     free(snq->clauses);
-    free(SpQ(self)->field);
 
     spanq_destroy_i(self);
 }
@@ -2136,7 +2132,7 @@ Query *spannq_new(int slop, bool in_order)
 
     SpQ(self)->get_spans    = &spannq_get_spans;
     SpQ(self)->get_terms    = &spannq_get_terms;
-    SpQ(self)->field        = estrdup((char *)EMPTY_STRING);
+    SpQ(self)->field        = NULL;
 
     self->type              = SPAN_NEAR_QUERY;
     self->rewrite           = &spannq_rewrite;
@@ -2159,13 +2155,12 @@ Query *spannq_add_clause_nr(Query *self, Query *clause)
               "SpanQuery.", q_get_query_name(clause->type));
     }
     if (curr_index == 0) {
-        free(SpQ(self)->field);
-        SpQ(self)->field = estrdup(SpQ(clause)->field);
+        SpQ(self)->field = SpQ(clause)->field;
     }
-    else if (strcmp(SpQ(self)->field, SpQ(clause)->field) != 0) {
+    else if (SpQ(self)->field != SpQ(clause)->field) {
         RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
               "Attempted to add a SpanQuery with field \"%s\" to SpanNearQuery "
-              "with field \"%s\"", SpQ(clause)->field, SpQ(self)->field);
+              "with field \"%s\"", S(SpQ(clause)->field), S(SpQ(self)->field));
     }
     if (curr_index >= SpNQ(self)->c_capa) {
         SpNQ(self)->c_capa <<= 1;
@@ -2187,7 +2182,7 @@ Query *spannq_add_clause(Query *self, Query *clause)
  *
  *****************************************************************************/
 
-static char *spanxq_to_s(Query *self, const char *field)
+static char *spanxq_to_s(Query *self, Symbol field)
 {
     SpanNotQuery *sxq = SpXQ(self);
     char *inc_s = sxq->inc->to_s(sxq->inc, field);
@@ -2237,8 +2232,6 @@ static void spanxq_destroy(Query *self)
     q_deref(sxq->inc);
     q_deref(sxq->exc);
 
-    free(SpQ(self)->field);
-
     spanq_destroy_i(self);
 }
 
@@ -2261,18 +2254,18 @@ static int spanxq_eq(Query *self, Query *o)
 Query *spanxq_new_nr(Query *inc, Query *exc)
 {
     Query *self;
-    if (strcmp(SpQ(inc)->field, SpQ(inc)->field) != 0) {
+    if (SpQ(inc)->field != SpQ(inc)->field) {
         RAISE(ARG_ERROR, "All clauses in a SpanQuery must have the same field. "
               "Attempted to add a SpanQuery with field \"%s\" along with a "
               "SpanQuery with field \"%s\" to an SpanNotQuery",
-              SpQ(inc)->field, SpQ(exc)->field);
+              S(SpQ(inc)->field), S(SpQ(exc)->field));
     }
     self = q_new(SpanNotQuery);
 
     SpXQ(self)->inc         = inc;
     SpXQ(self)->exc         = exc;
 
-    SpQ(self)->field        = estrdup(SpQ(inc)->field);
+    SpQ(self)->field        = SpQ(inc)->field;
     SpQ(self)->get_spans    = &spanxe_new;
     SpQ(self)->get_terms    = &spanxq_get_terms;
 
@@ -2311,23 +2304,21 @@ Query *spanxq_new(Query *inc, Query *exc)
 
 #define SpPfxQ(query) ((SpanPrefixQuery *)(query))
 
-static char *spanprq_to_s(Query *self, const char *current_field) 
+static char *spanprq_to_s(Query *self, Symbol default_field)
 {
     char *buffer, *bptr;
     const char *prefix = SpPfxQ(self)->prefix;
-    const char *field = SpQ(self)->field;
+    Symbol field = SpQ(self)->field;
     size_t plen = strlen(prefix);
-    size_t flen = strlen(field);
+    size_t flen = sym_len(field);
 
     bptr = buffer = ALLOC_N(char, plen + flen + 35);
 
-    if (strcmp(field, current_field) != 0) {
-        sprintf(bptr, "%s:", field);
-        bptr += flen + 1;
+    if (default_field == NULL || (field != default_field)) {
+        bptr += sprintf(bptr, "%s:", S(field));
     }
 
-    sprintf(bptr, "%s*", prefix);
-    bptr += plen + 1;
+    bptr += sprintf(bptr, "%s*", prefix);
     if (self->boost != 1.0) {
         *bptr = '^';
         dbl_to_s(++bptr, self->boost);
@@ -2338,9 +2329,8 @@ static char *spanprq_to_s(Query *self, const char *current_field)
 
 static Query *spanprq_rewrite(Query *self, IndexReader *ir)
 {
-    const char *field = SpQ(self)->field;
-    const int field_num = fis_get_field_num(ir->fis, field);
-    Query *volatile q = spanmtq_new_conf(field, SpPfxQ(self)->max_terms);
+    const int field_num = fis_get_field_num(ir->fis, SpQ(self)->field);
+    Query *volatile q = spanmtq_new_conf(SpQ(self)->field, SpPfxQ(self)->max_terms);
     q->boost = self->boost;        /* set the boost */
 
     if (field_num >= 0) {
@@ -2350,7 +2340,7 @@ static Query *spanprq_rewrite(Query *self, IndexReader *ir)
         size_t prefix_len = strlen(prefix);
 
         TRY
-            do { 
+            do {
                 if (strncmp(term, prefix, prefix_len) != 0) {
                     break;
                 }
@@ -2366,27 +2356,26 @@ static Query *spanprq_rewrite(Query *self, IndexReader *ir)
 
 static void spanprq_destroy(Query *self)
 {
-    free(SpQ(self)->field);
     free(SpPfxQ(self)->prefix);
     spanq_destroy_i(self);
 }
 
 static unsigned long spanprq_hash(Query *self)
 {
-    return str_hash(SpQ(self)->field) ^ str_hash(SpPfxQ(self)->prefix);
+    return sym_hash(SpQ(self)->field) ^ str_hash(SpPfxQ(self)->prefix);
 }
 
 static int spanprq_eq(Query *self, Query *o)
 {
-    return (strcmp(SpPfxQ(self)->prefix, SpPfxQ(o)->prefix) == 0) 
-        && (strcmp(SpQ(self)->field,  SpQ(o)->field) == 0);
+    return (strcmp(SpPfxQ(self)->prefix, SpPfxQ(o)->prefix) == 0)
+        && (SpQ(self)->field == SpQ(o)->field);
 }
 
-Query *spanprq_new(const char *field, const char *prefix)
+Query *spanprq_new(Symbol field, const char *prefix)
 {
     Query *self = q_new(SpanPrefixQuery);
 
-    SpQ(self)->field        = estrdup(field);
+    SpQ(self)->field        = field;
     SpPfxQ(self)->prefix    = estrdup(prefix);
     SpPfxQ(self)->max_terms = SPAN_PREFIX_QUERY_MAX_TERMS;