ferret 0.11.6 → 0.11.8.4

data/ext/q_fuzzy.c

@@ -1,21 +1,41 @@
 #include <string.h>
 #include "search.h"
 #include "helper.h"
+#include "internal.h"
 
 /****************************************************************************
  *
  * FuzzyStuff
  *
- * The main method here is the fuzq_score method which scores a term against
- * another term. The other methods all act in support.
+ * The main method here is the fuzq_score_mn method which scores a term
+ * against another term. The other methods all act in support.
+ *
+ * To learn more about the fuzzy scoring algorithm see;
+ *
+ *     http://en.wikipedia.org/wiki/Levenshtein_distance
  *
  ****************************************************************************/
 
-static INLINE int fuzq_calculate_max_distance(FuzzyQuery *fuzq, int m) 
+/**
+ * Calculate the maximum nomber of allowed edits (or maximum edit distance)
+ * for a word to be a match.
+ *
+ * Note that fuzq->text_len and m are both the lengths text *after* the prefix
+ * so `MIN(fuzq->text_len, m) + fuzq->pre_len)` actually gets the byte length
+ * of the shorter string out of the query string and the index term being
+ * compared.
+ */
+static INLINE int fuzq_calculate_max_distance(FuzzyQuery *fuzq, int m)
 {
     return (int)((1.0 - fuzq->min_sim) * (MIN(fuzq->text_len, m) + fuzq->pre_len));
 }
 
+/**
+ * The max-distance formula gets used a lot - it needs to be calculated for
+ * every possible match in the index - so we cache the results for all
+ * lengths up to the TYPICAL_LONGEST_WORD limit. For words longer than this we
+ * calculate the value live.
+ */
 static void fuzq_initialize_max_distances(FuzzyQuery *fuzq)
 {
     int i;
@@ -24,10 +44,79 @@ static void fuzq_initialize_max_distances(FuzzyQuery *fuzq)
     }
 }
 
+/**
+ * Return the cached max-distance value if the word is within the
+ * TYPICAL_LONGEST_WORD limit.
+ */
 static INLINE int fuzq_get_max_distance(FuzzyQuery *fuzq, int m)
 {
-    return (m < TYPICAL_LONGEST_WORD) ? fuzq->max_distances[m]
-        : fuzq_calculate_max_distance(fuzq, m);
+    if (m < TYPICAL_LONGEST_WORD)
+        return fuzq->max_distances[m];
+    return fuzq_calculate_max_distance(fuzq, m);
+}
+
+/**
+ * Calculate the similarity score for the +target+ against the query.
+ *
+ * @params fuzq The Fuzzy Query
+ * @params target *the term to compare against minus the prefix
+ * @params m the string length of +target+
+ * @params n the string length of the query string minus length of the prefix
+ */
+static INLINE float fuzq_score_mn(FuzzyQuery *fuzq,
+                                  const char *target,
+                                  const int m, const int n)
+{
+    int i, j, prune;
+    int *d_curr, *d_prev;
+    const char *text = fuzq->text;
+    const int max_distance = fuzq_get_max_distance(fuzq, m);
+
+    /* Just adding the characters of m to n or vice-versa results in
+     * too many edits for example "pre" length is 3 and "prefixes"
+     * length is 8. We can see that given this optimal circumstance,
+     * the edit distance cannot be less than 5 which is 8-3 or more
+     * precisesly Math.abs(3-8). If our maximum edit distance is 4,
+     * then we can discard this word without looking at it. */
+    if (max_distance < ABS(m-n)) {
+        return 0.0f;
+    }
+
+    d_curr = fuzq->da;
+    d_prev = d_curr + n + 1;
+
+    /* init array */
+    for (j = 0; j <= n; j++) {
+        d_curr[j] = j;
+    }
+
+    /* start computing edit distance */
+    for (i = 0; i < m;) {
+        char s_i = target[i];
+        /* swap d_current into d_prev */
+        int *d_tmp = d_prev;
+        d_prev = d_curr;
+        d_curr = d_tmp;
+        prune = (d_curr[0] = ++i) > max_distance;
+
+        for (j = 0; j < n; j++) {
+            d_curr[j + 1] = (s_i == text[j])
+                ? min3(d_prev[j + 1] + 1, d_curr[j] + 1, d_prev[j])
+                : min3(d_prev[j + 1], d_curr[j], d_prev[j]) + 1;
+            if (prune && d_curr[j + 1] <= max_distance) {
+                prune = false;
+            }
+        }
+        if (prune) {
+            return 0.0f;
+        }
+    }
+
+    /* this will return less than 0.0 when the edit distance is greater
+     * than the number of characters in the shorter word.  but this was
+     * the formula that was previously used in FuzzyTermEnum, so it has
+     * not been changed (even though min_sim must be greater than 0.0) */
+    return 1.0f - ((float)d_curr[n] / (float) (fuzq->pre_len + min2(n, m)));
 }
 
 /**
@@ -41,76 +130,15 @@ float fuzq_score(FuzzyQuery *fuzq, const char *target)
     const int m = (int)strlen(target);
     const int n = fuzq->text_len;
 
-    if (n == 0)  {
-        /* we don't have anything to compare.  That means if we just add
-         * the letters for m we get the new word */
-        return fuzq->pre_len == 0 ? 0.0f : 1.0f - ((float) m / fuzq->pre_len);
-    }
-    else if (m == 0) {
-        return fuzq->pre_len == 0 ? 0.0f : 1.0f - ((float) n / fuzq->pre_len);
-    }
-    else {
-        int i, j, prune;
-        int *d_curr, *d_prev;
-        const char *text = fuzq->text;
-        const int max_distance = fuzq_get_max_distance(fuzq, m);
-
-        /*
-         printf("n%dm%dmd%ddiff%d<%s><%s>\n", n, m, max_distance, m-n,
-               fuzq->text, target);
-         */
-        if (max_distance < ((m > n) ? (m-n) : (n-m))) { /* abs */
-            /* Just adding the characters of m to n or vice-versa results in
-             * too many edits for example "pre" length is 3 and "prefixes"
-             * length is 8. We can see that given this optimal circumstance,
-             * the edit distance cannot be less than 5 which is 8-3 or more
-             * precisesly Math.abs(3-8). If our maximum edit distance is 4,
-             * then we can discard this word without looking at it. */
+    /* we don't have anything to compare.  That means if we just add
+     * the letters for m we get the new word */
+    if (m == 0 || n == 0) {
+        if (fuzq->pre_len == 0)
             return 0.0f;
-        }
-
-        d_curr = fuzq->da;
-        d_prev = d_curr + n + 1;
-
-        /* init array */
-        for (j = 0; j <= n; j++) {
-            d_curr[j] = j;
-        }
-
-        /* start computing edit distance */
-        for (i = 0; i < m;) {
-           char s_i = target[i];
-           /* swap d_current into d_prev */
-           int *d_tmp = d_prev;
-           d_prev = d_curr;
-           d_curr = d_tmp;
-           prune = (d_curr[0] = ++i) > max_distance;
-
-           for (j = 0; j < n; j++) {
-               d_curr[j + 1] = (s_i == text[j])
-                   ? min3(d_prev[j + 1] + 1, d_curr[j] + 1, d_prev[j])
-                   : min3(d_prev[j + 1], d_curr[j], d_prev[j]) + 1;
-               if (prune && d_curr[j + 1] <= max_distance) {
-                   prune = false;
-               }
-           }
-           if (prune) {
-               return 0.0f;
-           }
-        }
-
-        /*
-        printf("<%f, d_curr[n] = %d min_len = %d>",
-               1.0f - ((float)d_curr[m] / (float) (fuzq->pre_len + min2(n, m))),
-               d_curr[m], fuzq->pre_len + min2(n, m));
-               */
-
-        /* this will return less than 0.0 when the edit distance is greater
-         * than the number of characters in the shorter word.  but this was
-         * the formula that was previously used in FuzzyTermEnum, so it has
-         * not been changed (even though min_sim must be greater than 0.0) */
-        return 1.0f - ((float)d_curr[n] / (float) (fuzq->pre_len + min2(n, m)));
+        return 1.0f - ((float) (m+n) / fuzq->pre_len);
     }
+
+    return fuzq_score_mn(fuzq, target, m, n);
 }
 
 /****************************************************************************
@@ -121,22 +149,18 @@ float fuzq_score(FuzzyQuery *fuzq, const char *target)
 
 #define FzQ(query) ((FuzzyQuery *)(query))
 
-static char *fuzq_to_s(Query *self, const char *curr_field) 
+static char *fuzq_to_s(Query *self, Symbol curr_field)
 {
     char *buffer, *bptr;
     char *term = FzQ(self)->term;
-    char *field = FzQ(self)->field;
-    int tlen = (int)strlen(term);
-    int flen = (int)strlen(field);
-    bptr = buffer = ALLOC_N(char, tlen + flen + 70);
-
-    if (strcmp(curr_field, field) != 0) {
-        sprintf(bptr, "%s:", field);
-        bptr += flen + 1;
+    Symbol field = FzQ(self)->field;
+    bptr = buffer = ALLOC_N(char, strlen(term) + sym_len(field) + 70);
+
+    if (curr_field != field) {
+        bptr += sprintf(bptr, "%s:", S(field));
     }
 
-    sprintf(bptr, "%s~", term);
-    bptr += tlen + 1;
+    bptr += sprintf(bptr, "%s~", term);
     if (FzQ(self)->min_sim != 0.5) {
         dbl_to_s(bptr, FzQ(self)->min_sim);
         bptr += strlen(bptr);
@@ -155,77 +179,65 @@ static Query *fuzq_rewrite(Query *self, IndexReader *ir)
     Query *q;
     FuzzyQuery *fuzq = FzQ(self);
 
+    int pre_len = fuzq->pre_len;
+    char *prefix = NULL;
     const char *term = fuzq->term;
-    const char *field = fuzq->field;
-    const int field_num = fis_get_field_num(ir->fis, field);
+    const int field_num = fis_get_field_num(ir->fis, fuzq->field);
+    TermEnum *te;
 
     if (field_num < 0) {
-        q = bq_new(true);
+        return bq_new(true);
     }
-    else if (fuzq->pre_len >= (int)strlen(term)) {
-        q = tq_new(field, term);
+    if (fuzq->pre_len >= (int)strlen(term)) {
+        return tq_new(fuzq->field, term);
     }
-    else {
-        TermEnum *te;
-        char *prefix = NULL;
-        int pre_len = fuzq->pre_len;
-
-        q = multi_tq_new_conf(fuzq->field, MTQMaxTerms(self), fuzq->min_sim);
-
-        if (pre_len > 0) {
-            prefix = ALLOC_N(char, pre_len + 1);
-            strncpy(prefix, term, pre_len);
-            prefix[pre_len] = '\0';
-            te = ir->terms_from(ir, field_num, prefix);
-        }
-        else {
-            te = ir->terms(ir, field_num);
-        }
 
-        fuzq->scale_factor = (float)(1.0 / (1.0 - fuzq->min_sim));
-        fuzq->text = term + pre_len;
-        fuzq->text_len = (int)strlen(fuzq->text);
-        fuzq->da = REALLOC_N(fuzq->da, int, fuzq->text_len * 2 + 2);
-        fuzq_initialize_max_distances(fuzq);
-
-        if (te) {
-            const char *curr_term = te->curr_term;
-            const char *curr_suffix = curr_term + pre_len;
-            float score = 0.0;
+    q = multi_tq_new_conf(fuzq->field, MTQMaxTerms(self), fuzq->min_sim);
+    if (pre_len > 0) {
+        prefix = ALLOC_N(char, pre_len + 1);
+        strncpy(prefix, term, pre_len);
+        prefix[pre_len] = '\0';
+        te = ir->terms_from(ir, field_num, prefix);
+    }
+    else {
+        te = ir->terms(ir, field_num);
+    }
 
+    assert(NULL != te);
 
-            do { 
-                if ((prefix && strncmp(curr_term, prefix, pre_len) != 0)) {
-                    break;
-                }
+    fuzq->scale_factor = (float)(1.0 / (1.0 - fuzq->min_sim));
+    fuzq->text = term + pre_len;
+    fuzq->text_len = (int)strlen(fuzq->text);
+    fuzq->da = REALLOC_N(fuzq->da, int, fuzq->text_len * 2 + 2);
+    fuzq_initialize_max_distances(fuzq);
 
-                score = fuzq_score(fuzq, curr_suffix);
-                /*
-                 printf("%s:%s:%f < %f\n", curr_term, term, score, min_score);
-                 */
-                multi_tq_add_term_boost(q, curr_term, score);
+    do {
+        const char *curr_term = te->curr_term;
+        const char *curr_suffix = curr_term + pre_len;
+        float score = 0.0;
 
-            } while (te->next(te) != NULL);
+        if (prefix && strncmp(curr_term, prefix, pre_len) != 0)
+            break;
 
-            te->close(te);
-        }
-        free(prefix);
-    }
+        score = fuzq_score(fuzq, curr_suffix);
+        multi_tq_add_term_boost(q, curr_term, score);
+    } while (te->next(te) != NULL);
 
+    te->close(te);
+    if (prefix) free(prefix);
     return q;
 }
 
 static void fuzq_destroy(Query *self)
 {
     free(FzQ(self)->term);
-    free(FzQ(self)->field);
     free(FzQ(self)->da);
     q_destroy_i(self);
 }
 
 static unsigned long fuzq_hash(Query *self)
 {
-    return str_hash(FzQ(self)->term) ^ str_hash(FzQ(self)->field)
+    return str_hash(FzQ(self)->term) ^ sym_hash(FzQ(self)->field)
         ^ float2int(FzQ(self)->min_sim) ^ FzQ(self)->pre_len;
 }
 
@@ -235,17 +247,17 @@ static int fuzq_eq(Query *self, Query *o)
     FuzzyQuery *fq2 = FzQ(o);
 
     return (strcmp(fq1->term, fq2->term) == 0)
-        && (strcmp(fq1->field, fq2->field) == 0)
+        && (fq1->field == fq2->field)
         && (fq1->pre_len == fq2->pre_len)
         && (fq1->min_sim == fq2->min_sim);
 }
 
-Query *fuzq_new_conf(const char *field, const char *term,
+Query *fuzq_new_conf(Symbol field, const char *term,
                      float min_sim, int pre_len, int max_terms)
 {
     Query *self = q_new(FuzzyQuery);
 
-    FzQ(self)->field      = estrdup(field);
+    FzQ(self)->field      = field;
     FzQ(self)->term       = estrdup(term);
     FzQ(self)->pre_len    = pre_len ? pre_len : DEF_PRE_LEN;
     FzQ(self)->min_sim    = min_sim ? min_sim : DEF_MIN_SIM;
@@ -262,7 +274,7 @@ Query *fuzq_new_conf(const char *field, const char *term,
     return self;
 }
 
-Query *fuzq_new(const char *field, const char *term)
+Query *fuzq_new(Symbol field, const char *term)
 {
     return fuzq_new_conf(field, term, 0.0f, 0, 0);
 }

data/ext/q_match_all.c

@@ -1,5 +1,6 @@
 #include "search.h"
 #include <string.h>
+#include "internal.h"
 
 /***************************************************************************
  *
@@ -110,9 +111,9 @@ static Weight *maw_new(Query *query, Searcher *searcher)
  *
  ***************************************************************************/
 
-char *maq_to_s(Query *self, const char *field)
+static char *maq_to_s(Query *self, Symbol default_field)
 {
-    (void)field;
+    (void)default_field;
     if (self->boost == 1.0) {
         return estrdup("*");
     } else {

data/ext/q_multi_term.c

@@ -1,7 +1,8 @@
 #include <string.h>
 #include "search.h"
-#include "priorityqueue.h"
 #include "helper.h"
+#include "symbol.h"
+#include "internal.h"
 
 #define MTQ(query) ((MultiTermQuery *)(query))
 
@@ -141,7 +142,7 @@ static TermDocEnumWrapper *tdew_new(const char *term, TermDocEnum *tde,
 typedef struct MultiTermScorer
 {
     Scorer                super;
-    const char           *field;
+    Symbol                field;
     uchar                *norms;
     Weight               *weight;
     TermDocEnumWrapper  **tdew_a;
@@ -176,7 +177,7 @@ static bool multi_tsc_next(Scorer *self)
         }
         mtsc->tdew_pq = tdew_pq;
     }
-    
+
     tdew = (TermDocEnumWrapper *)pq_top(tdew_pq);
     if (tdew == NULL) {
         return false;
@@ -259,7 +260,7 @@ static Explanation *multi_tsc_explain(Scorer *self, int doc_num)
             expl_add_detail(expl,
                 expl_new(sim_tf(self->similarity, (float)freq) * tdew->boost,
                          "tf(term_freq(%s:%s)=%d)^%f",
-                         mtsc->field, tdew->term, freq, tdew->boost));
+                         S(mtsc->field), tdew->term, freq, tdew->boost));
 
             total_score += sim_tf(self->similarity, (float)freq) * tdew->boost;
 
@@ -294,7 +295,7 @@ static void multi_tsc_destroy(Scorer *self)
     scorer_destroy_i(self);
 }
 
-static Scorer *multi_tsc_new(Weight *weight, const char *field,
+static Scorer *multi_tsc_new(Weight *weight, Symbol field,
                              TermDocEnumWrapper **tdew_a, int tdew_cnt,
                              uchar *norms)
 {
@@ -367,7 +368,7 @@ static Scorer *multi_tw_scorer(Weight *self, IndexReader *ir)
     return multi_tsc;
 }
 
-Explanation *multi_tw_explain(Weight *self, IndexReader *ir, int doc_num)
+static Explanation *multi_tw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
     Explanation *expl;
     Explanation *idf_expl1;
@@ -383,19 +384,20 @@ Explanation *multi_tw_explain(Weight *self, IndexReader *ir, int doc_num)
 
     char *query_str;
     MultiTermQuery *mtq = MTQ(self->query);
-    const char *field = mtq->field;
+    const char *field = S(mtq->field);
     PriorityQueue *bt_pq = mtq->boosted_terms;
     int i;
     int total_doc_freqs = 0;
     char *doc_freqs = NULL;
     size_t len = 0, pos = 0;
-    const int field_num = fis_get_field_num(ir->fis, field);
+    const int field_num = fis_get_field_num(ir->fis, mtq->field);
 
     if (field_num < 0) {
-        return expl_new(0.0, "field \"%s\" does not exist in the index", field);
+        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);
 
     expl = expl_new(0.0, "weight(%s in %d), product of:", query_str, doc_num);
 
@@ -407,8 +409,7 @@ Explanation *multi_tw_explain(Weight *self, IndexReader *ir, int doc_num)
     for (i = bt_pq->size; i > 0; i--) {
         char *term = ((BoostedTerm *)bt_pq->heap[i])->term;
         int doc_freq = ir->doc_freq(ir, field_num, term);
-        sprintf(doc_freqs + pos, "(%s=%d) + ", term, doc_freq);
-        pos += strlen(doc_freqs + pos);
+        pos += sprintf(doc_freqs + pos, "(%s=%d) + ", term, doc_freq);
         total_doc_freqs += doc_freq;
     }
     pos -= 2; /* remove " + " from the end */
@@ -476,7 +477,6 @@ static Weight *multi_tw_new(Query *query, Searcher *searcher)
     int i;
     int doc_freq         = 0;
     Weight *self         = w_new(Weight, query);
-    const char *field    = MTQ(query)->field;
     PriorityQueue *bt_pq = MTQ(query)->boosted_terms;
 
     self->scorer         = &multi_tw_scorer;
@@ -488,7 +488,7 @@ static Weight *multi_tw_new(Query *query, Searcher *searcher)
     self->idf            = 0.0;
 
     for (i = bt_pq->size; i > 0; i--) {
-        doc_freq += searcher->doc_freq(searcher, field,
+        doc_freq += searcher->doc_freq(searcher, MTQ(query)->field,
                                        ((BoostedTerm *)bt_pq->heap[i])->term);
     }
     self->idf += sim_idf(self->similarity, doc_freq,
@@ -502,13 +502,13 @@ static Weight *multi_tw_new(Query *query, Searcher *searcher)
  * MultiTermQuery
  ***************************************************************************/
 
-static char *multi_tq_to_s(Query *self, const char *curr_field) 
+static char *multi_tq_to_s(Query *self, Symbol default_field)
 {
     int i;
     PriorityQueue *boosted_terms = MTQ(self)->boosted_terms, *bt_pq_clone;
     BoostedTerm *bt;
     char *buffer, *bptr;
-    char *field = MTQ(self)->field;
+    const char *field = S(MTQ(self)->field);
     int flen = (int)strlen(field);
     int tlen = 0;
 
@@ -519,16 +519,14 @@ static char *multi_tq_to_s(Query *self, const char *curr_field)
 
     bptr = buffer = ALLOC_N(char, tlen + flen + 35);
 
-    if (strcmp(curr_field, field) != 0) {
-        sprintf(bptr, "%s:", field);
-        bptr += flen + 1;
+    if (default_field != MTQ(self)->field) {
+        bptr += sprintf(bptr, "%s:", field);
     }
 
     *(bptr++) = '"';
     bt_pq_clone = pq_clone(boosted_terms);
     while ((bt = (BoostedTerm *)pq_pop(bt_pq_clone)) != NULL) {
-        sprintf(bptr, "%s", bt->term);
-        bptr += (int)strlen(bptr);
+        bptr += sprintf(bptr, "%s", bt->term);
 
         if (bt->boost != 1.0) {
             *bptr = '^';
@@ -545,7 +543,7 @@ static char *multi_tq_to_s(Query *self, const char *curr_field)
     }
     bptr[-1] =  '"'; /* delete last '|' char */
     bptr[ 0] = '\0';
-    
+
     if (self->boost != 1.0) {
         *bptr = '^';
         dbl_to_s(++bptr, self->boost);
@@ -556,7 +554,6 @@ static char *multi_tq_to_s(Query *self, const char *curr_field)
 
 static void multi_tq_destroy_i(Query *self)
 {
-    free(MTQ(self)->field);
     pq_destroy(MTQ(self)->boosted_terms);
     q_destroy_i(self);
 }
@@ -564,18 +561,17 @@ static void multi_tq_destroy_i(Query *self)
 static void multi_tq_extract_terms(Query *self, HashSet *terms)
 {
     int i;
-    char *field = MTQ(self)->field;
     PriorityQueue *boosted_terms = MTQ(self)->boosted_terms;
     for (i = boosted_terms->size; i > 0; i--) {
         BoostedTerm *bt = (BoostedTerm *)boosted_terms->heap[i];
-        hs_add(terms, term_new(field, bt->term));
+        hs_add(terms, term_new(MTQ(self)->field, bt->term));
     }
 }
 
 static unsigned long multi_tq_hash(Query *self)
 {
     int i;
-    unsigned long hash = str_hash(MTQ(self)->field);
+    unsigned long hash = sym_hash(MTQ(self)->field);
     PriorityQueue *boosted_terms = MTQ(self)->boosted_terms;
     for (i = boosted_terms->size; i > 0; i--) {
         BoostedTerm *bt = (BoostedTerm *)boosted_terms->heap[i];
@@ -590,7 +586,7 @@ static int multi_tq_eq(Query *self, Query *o)
     PriorityQueue *boosted_terms1 = MTQ(self)->boosted_terms;
     PriorityQueue *boosted_terms2 = MTQ(o)->boosted_terms;
 
-    if (strcmp(MTQ(self)->field, MTQ(o)->field) != 0
+    if ((MTQ(self)->field != MTQ(o)->field)
         || boosted_terms1->size != boosted_terms2->size) {
         return false;
     }
@@ -607,7 +603,7 @@ static int multi_tq_eq(Query *self, Query *o)
 static MatchVector *multi_tq_get_matchv_i(Query *self, MatchVector *mv,
                                           TermVector *tv)
 {
-    if (strcmp(tv->field, MTQ(self)->field) == 0) {
+    if (tv->field == MTQ(self)->field) {
         int i;
         PriorityQueue *boosted_terms = MTQ(self)->boosted_terms;
         for (i = boosted_terms->size; i > 0; i--) {
@@ -625,7 +621,7 @@ static MatchVector *multi_tq_get_matchv_i(Query *self, MatchVector *mv,
     return mv;
 }
 
-Query *multi_tq_new_conf(const char *field, int max_terms, float min_boost)
+Query *multi_tq_new_conf(Symbol field, int max_terms, float min_boost)
 {
     Query *self;
 
@@ -636,7 +632,7 @@ Query *multi_tq_new_conf(const char *field, int max_terms, float min_boost)
 
     self                     = q_new(MultiTermQuery);
 
-    MTQ(self)->field         = estrdup(field);
+    MTQ(self)->field         = field;
     MTQ(self)->boosted_terms = pq_new(max_terms,
                                       (lt_ft)&boosted_term_less_than,
                                       (free_ft)&boosted_term_destroy);
@@ -654,7 +650,7 @@ Query *multi_tq_new_conf(const char *field, int max_terms, float min_boost)
     return self;
 }
 
-Query *multi_tq_new(const char *field)
+Query *multi_tq_new(Symbol field)
 {
     return multi_tq_new_conf(field, MULTI_TERM_QUERY_MAX_TERMS, 0.0);
 }