ferret 0.9.0 → 0.9.1

data/ext/q_const_score.c

@@ -9,9 +9,7 @@
 
 char *csw_to_s(Weight *self)
 {
-  char dbuf[32];
-  dbl_to_s(dbuf, self->value);
-  return epstrdup("ConstantScoreWeight(%s)", strlen(dbuf), dbuf);
+  return strfmt("ConstantScoreWeight(%f)", self->value);
 }
 
 void csw_destroy(void *p)
@@ -28,14 +26,13 @@ Explanation *csw_explain(Weight *self, IndexReader *ir, int doc_num)
 
   if (bv_get(bv, doc_num)) {
     expl = expl_create(self->value,
-        epstrdup("ConstantScoreQuery(%s), product of:",
-          strlen(filter_str), filter_str));
+        strfmt("ConstantScoreQuery(%s), product of:", filter_str));
     expl_add_detail(expl, expl_create(self->query->boost, estrdup("boost")));
     expl_add_detail(expl, expl_create(self->qnorm, estrdup("query_norm")));
   } else {
     expl = expl_create(self->value,
-        epstrdup("ConstantScoreQuery(%s), does not match id %d",
-          strlen(filter_str) + 20, filter_str, doc_num));
+        strfmt("ConstantScoreQuery(%s), does not match id %d",
+          filter_str, doc_num));
   }
   free(filter_str);
   return expl;
@@ -74,12 +71,9 @@ char *csq_to_s(Query *self, char *field)
   char *filter_str = filter->to_s(filter);
   char *buffer;
   if (self->boost == 1.0) {
-    buffer = epstrdup("ConstantScore(%s)", strlen(filter_str), filter_str);
+    buffer = strfmt("ConstantScore(%s)", filter_str);
   } else {
-    char dbuf[32];
-    dbl_to_s(dbuf, self->boost);
-    buffer = epstrdup("ConstantScore(%s)^%s",
-        strlen(filter_str) + strlen(dbuf), filter_str, dbuf);
+    buffer = strfmt("ConstantScore(%s)^%f", filter_str, self->boost);
   }
   free(filter_str);
   return buffer;;

data/ext/q_filtered_query.c

@@ -0,0 +1,206 @@
+#include "search.h"
+#include <string.h>
+
+Scorer *fqsc_create(Scorer *scorer, BitVector *bv, Similarity *sim);
+
+/***************************************************************************
+ *
+ * Weight
+ *
+ ***************************************************************************/
+
+char *fqw_to_s(Weight *self)
+{
+  return strfmt("FilteredQueryWeight(%f)", self->value);
+}
+
+void fqw_destroy(void *p)
+{
+  free(p);
+}
+
+float fqw_sum_of_squared_weights(Weight *self)
+{
+  Weight *sw = (Weight *)self->data;
+  return sw->sum_of_squared_weights(sw);
+}
+
+void fqw_normalize(Weight *self, float normalization_factor)
+{
+  Weight *sw = (Weight *)self->data;
+  return sw->normalize(sw, normalization_factor);
+}
+
+float fqw_get_value(Weight *self)
+{
+  Weight *sw = (Weight *)self->data;
+  return sw->get_value(sw);
+}
+
+Explanation *fqw_explain(Weight *self, IndexReader *ir, int doc_num)
+{
+  Weight *sw = (Weight *)self->data;
+  return sw->explain(sw, ir, doc_num);
+}
+
+Scorer *fqw_scorer(Weight *self, IndexReader *ir)
+{
+  Weight *sw = (Weight *)self->data;
+  Scorer *scorer = sw->scorer(sw, ir);
+  Filter *filter = ((FilteredQuery *)self->query->data)->filter;
+
+  return fqsc_create(scorer, filter->get_bv(filter, ir), self->similarity);
+}
+
+Weight *fqw_create(Query *query, Weight *sub_weight, Similarity *sim)
+{
+  Weight *self = ALLOC(Weight);
+  ZEROSET(self, Weight, 1);
+  self->data = sub_weight;
+
+  self->get_query = &w_get_query;
+  self->get_value = &fqw_get_value;
+  self->normalize = &fqw_normalize;
+  self->scorer    = &fqw_scorer;
+  self->explain   = &fqw_explain;
+  self->to_s      = &fqw_to_s;
+  self->destroy   = &fqw_destroy;
+  self->sum_of_squared_weights = &fqw_sum_of_squared_weights;
+
+  self->similarity = sim;
+  self->idf = 1.0;
+  self->query = query;
+  self->value = sub_weight->value;
+
+  return self;
+}
+
+/***************************************************************************
+ *
+ * FilteredQueryQuery
+ *
+ ***************************************************************************/
+
+char *fq_to_s(Query *self, char *field)
+{
+  FilteredQuery *fq = (FilteredQuery *)self->data;
+  char *filter_str = fq->filter->to_s(fq->filter);
+  char *query_str = fq->query->to_s(fq->query, field);
+  char *buffer;
+  if (self->boost == 1.0) {
+    buffer = strfmt("FilteredQuery(query:%s, filter:%s)",
+        query_str, filter_str);
+  } else {
+    buffer = strfmt("FilteredQuery(query:%s, filter:%s)^%f",
+        query_str, filter_str, self->boost);
+  }
+  free(filter_str);
+  free(query_str);
+  return buffer;;
+}
+
+void fq_destroy(void *p)
+{
+  Query *self = (Query *)p;
+  if (self->destroy_all) {
+    FilteredQuery *fq = (FilteredQuery *)self->data;
+    fq->filter->destroy(fq->filter);
+    fq->query->destroy(fq->query);
+  }
+  free(self->data);
+  q_destroy(self);
+}
+
+Weight *fq_create_weight(Query *self, Searcher *searcher)
+{
+  Query *sub_query = ((FilteredQuery *)self->data)->query;
+  return fqw_create(self, q_weight(sub_query, searcher),
+      searcher->similarity);
+}
+
+Query *fq_create(Query *query, Filter *filter)
+{
+  Query *self = q_create();
+  FilteredQuery *fq = ALLOC(FilteredQuery);
+  fq->query = query;
+  fq->filter = filter;
+  self->type = FILTERED_QUERY;
+  self->data = fq;
+  self->create_weight = &fq_create_weight;
+  self->to_s = &fq_to_s;
+  self->destroy = &fq_destroy;
+
+  return self;
+}
+
+/***************************************************************************
+ *
+ * FilteredQueryScorer
+ *
+ ***************************************************************************/
+
+typedef struct FilteredQueryScorer {
+  Scorer *sub_scorer;
+  BitVector *bv;
+} FilteredQueryScorer;
+
+float fqsc_score(Scorer *self)
+{
+  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
+  return sub_sc->score(sub_sc);
+}
+
+bool fqsc_next(Scorer *self)
+{
+  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
+  BitVector *bv = ((FilteredQueryScorer *)self->data)->bv;
+  while (sub_sc->next(sub_sc)) {
+    self->doc = sub_sc->doc;
+    if (bv_get(bv, self->doc)) return true;
+  }
+  return false;
+}
+
+bool fqsc_skip_to(Scorer *self, int doc_num)
+{
+  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
+  BitVector *bv = ((FilteredQueryScorer *)self->data)->bv;
+  if (sub_sc->skip_to(sub_sc, doc_num)) {
+    self->doc = sub_sc->doc;
+    do {
+      if (bv_get(bv, self->doc)) return true;
+    } while (sub_sc->next(sub_sc));
+  }
+  return false;
+}
+
+Explanation *fqsc_explain(Scorer *self, int doc_num)
+{
+  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
+  return sub_sc->explain(sub_sc, doc_num);
+}
+
+void fqsc_destroy(void *p)
+{
+  Scorer *self = (Scorer *)p;
+  FilteredQueryScorer *fqsc = (FilteredQueryScorer *)self->data;
+  bv_destroy(fqsc->bv);
+  fqsc->sub_scorer->destroy(fqsc->sub_scorer);
+  scorer_destroy(self);
+}
+
+Scorer *fqsc_create(Scorer *scorer, BitVector *bv, Similarity *sim)
+{
+  Scorer *self = scorer_create(sim);
+  FilteredQueryScorer *fqsc = ALLOC(FilteredQueryScorer);
+  fqsc->sub_scorer = scorer;
+  fqsc->bv = bv;
+  self->data = fqsc;
+
+  self->score = &fqsc_score;
+  self->next = &fqsc_next;
+  self->skip_to = &fqsc_skip_to;
+  self->explain = &fqsc_explain;
+  self->destroy = &fqsc_destroy;
+  return self;
+}

data/ext/q_fuzzy.c

@@ -216,21 +216,24 @@ Query *fuzq_rewrite(Query *self, IndexReader *ir)
       TermBuffer *tb = te->tb_curr;
       float score = 0.0, min_score = fuzq->min_sim;
 
-      do { 
-        if (strcmp(tb->field, field) != 0 ||
-            (prefix && strncmp(tb->text, prefix, pre_len) != 0))
-          break;
-
-        score = fuzq_score(fuzq, tb->text + pre_len);
-        //printf("%s:%s:%f\n", tb->text, fuzq->text, score);
-
-        if (score > min_score) {
-          pq_insert(term_pq, scored_term_create(tb_get_term(tb), score));
-          if (pq_full(term_pq))
-            min_score = ((ScoredTerm *)pq_top(term_pq))->score;
-        }
-      } while ((tb = te->next(te)) != NULL);
-      te->close(te);
+      TRY
+        do { 
+          if (strcmp(tb->field, field) != 0 ||
+              (prefix && strncmp(tb->text, prefix, pre_len) != 0))
+            break;
+
+          score = fuzq_score(fuzq, tb->text + pre_len);
+          //printf("%s:%s:%f\n", tb->text, fuzq->text, score);
+
+          if (score > min_score) {
+            pq_insert(term_pq, scored_term_create(tb_get_term(tb), score));
+            if (pq_full(term_pq))
+              min_score = ((ScoredTerm *)pq_top(term_pq))->score;
+          }
+        } while ((tb = te->next(te)) != NULL);
+      XFINALLY
+        te->close(te);
+      XENDTRY
     }
     free(prefix);
 

data/ext/q_match_all.c

@@ -9,9 +9,7 @@
 
 char *maw_to_s(Weight *self)
 {
-  char dbuf[32];
-  dbl_to_s(dbuf, self->value);
-  return epstrdup("MatchAllWeight(%s)", strlen(dbuf), dbuf);
+  return strfmt("MatchAllWeight(%f)", self->value);
 }
 
 void maw_destroy(void *p)
@@ -28,7 +26,7 @@ Explanation *maw_explain(Weight *self, IndexReader *ir, int doc_num)
     expl_add_detail(expl, expl_create(self->qnorm, estrdup("query_norm")));
   } else {
     expl = expl_create(self->value,
-        epstrdup("MatchAllQuery: doc %d was deleted", 20, doc_num));
+        strfmt("MatchAllQuery: doc %d was deleted", doc_num));
   }
 
   return expl;
@@ -66,9 +64,7 @@ char *maq_to_s(Query *self, char *field)
   if (self->boost == 1.0) {
     return estrdup("MatchAll");
   } else {
-    char dbuf[32];
-    dbl_to_s(dbuf, self->boost);
-    return epstrdup("MatchAll^%s", strlen(dbuf), dbuf);
+    return strfmt("MatchAll^%f", self->boost);
   }
 }
 

data/ext/q_multi_phrase.c

@@ -1,6 +1,8 @@
 #include <string.h>
 #include "search.h"
 
+static char * const FIELD_CHANGE_ERROR_MSG = "All phrase terms must be in the same field.";
+
 /***************************************************************************
  *
  * MultiPhraseWeight
@@ -9,9 +11,7 @@
 
 char *mphw_to_s(Weight *self)
 {
-  char dbuf[32];
-  dbl_to_s(dbuf, self->value);
-  return epstrdup("MultiPhraseWeight(%s)", strlen(dbuf), dbuf);
+  return strfmt("MultiPhraseWeight(%f)", self->value);
 }
 
 Scorer *mphw_scorer(Weight *self, IndexReader *ir)
@@ -63,9 +63,7 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
   int len = 0, pos = 0;
 
   Explanation *expl = expl_create(0.0,
-      epstrdup("weight(%s in %d), product of:",
-        strlen(query_str) + 20,
-        query_str, doc_num));
+      strfmt("weight(%s in %d), product of:", query_str, doc_num));
 
   for (i = 0; i < mphq->t_cnt; i++) {
     for (j = 0; j < mphq->pt_cnt[i]; j++) {
@@ -84,14 +82,14 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
   doc_freqs[pos] = 0;
 
   Explanation *idf_expl1 = expl_create(self->idf,
-      epstrdup("idf(%s:<%s>)", strlen(mphq->field) + pos, mphq->field, doc_freqs));
+      strfmt("idf(%s:<%s>)", mphq->field, doc_freqs));
   Explanation *idf_expl2 = expl_create(self->idf,
-      epstrdup("idf(%s:<%s>)", strlen(mphq->field) + pos, mphq->field, doc_freqs));
+      strfmt("idf(%s:<%s>)", mphq->field, doc_freqs));
   free(doc_freqs);
   
   // explain query weight
   Explanation *query_expl = expl_create(0.0, 
-      epstrdup("query_weight(%s), product of:", strlen(query_str), query_str));
+      strfmt("query_weight(%s), product of:", query_str));
 
   if (self->query->boost != 1.0) {
     expl_add_detail(query_expl, expl_create(self->query->boost, estrdup("boost")));
@@ -107,8 +105,7 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
  
   // explain field weight
   Explanation *field_expl = expl_create(0.0, 
-      epstrdup("field_weight(%s in %d), product of:",
-        strlen(query_str) + 20, query_str, doc_num));
+      strfmt("field_weight(%s in %d), product of:", query_str, doc_num));
   free(query_str);
 
   Scorer *scorer = self->scorer(self, ir);
@@ -122,8 +119,7 @@ Explanation *mphw_explain(Weight *self, IndexReader *ir, int doc_num)
     ? sim_decode_norm(self->similarity, field_norms[doc_num])
     : 0.0;
   Explanation *field_norm_expl = expl_create(field_norm,
-    epstrdup("field_norm(field=%s, doc=%d)",
-        strlen(mphq->field) + 20, mphq->field, doc_num));
+    strfmt("field_norm(field=%s, doc=%d)", mphq->field, doc_num));
 
   expl_add_detail(field_expl, field_norm_expl);
 
@@ -202,7 +198,7 @@ void mphq_add_terms(Query *self, Term **terms, int t_cnt, int pos_inc)
     position = mphq->positions[index - 1] + pos_inc;
     for (i = 0; i < t_cnt; i++) {
       if (strcmp(terms[i]->field, mphq->field) != 0) {
-        eprintf(ARG_ERROR, "All phrase terms must be in the same field. Current phrase is %s, tried to add %s\n", mphq->field, terms[i]->field);
+        RAISE(ARG_ERROR, FIELD_CHANGE_ERROR_MSG);
       }
     }
   }

data/ext/q_parser.c

@@ -1686,7 +1686,7 @@ int yyerror(QParser *qp, char const *msg)
 {
   if (!qp->handle_parse_errors) {
     if (qp->clean_str) free(qp->qstr);
-    eprintf(PARSE_ERROR, msg);
+    RAISE(PARSE_ERROR, (char *)msg);
   }
   return 0;
 }
@@ -1811,8 +1811,35 @@ Query *get_fuzzy_q(QParser *qp, char *field, char *word, char *slop_str)
 
 Query *get_wild_q(QParser *qp, char *field, char *pattern)
 {
+  Query *q;
+  bool is_prefix = false;
+  char *p;
+  int len = strlen(pattern);
+
   if (qp->wild_lower) lower_str(pattern);
-  return wcq_create(term_create(field, pattern));;
+  
+  /* simplify the wildcard query to a prefix query if possible. Basically a
+   * prefix query is any wildcard query that has a '*' as the last character
+   * and no other wildcard characters before it. */
+  if (pattern[len-1] == '*') {
+    is_prefix = true;
+    for (p = &pattern[len-2]; p >= pattern; p--) {
+      if (*p == '*' || *p == '?') {
+        is_prefix = false;
+        break;
+      }
+    }
+  }
+  
+  if (is_prefix) {
+    /* chop off the '*' temporarily to create the query */
+    pattern[len-1] = 0;
+    q = prefixq_create(term_create(field, pattern));;
+    pattern[len-1] = '*';
+  } else {
+    q = wcq_create(term_create(field, pattern));;
+  }
+  return q;
 }
 
 HashSet *add_field(QParser *qp, char *field)

data/ext/q_phrase.c

@@ -1,6 +1,8 @@
 #include <string.h>
 #include "search.h"
 
+static char * const FIELD_CHANGE_ERROR_MSG = "Field illegally changed in the phrase";
+
 /***************************************************************************
  *
  * PhraseWeight
@@ -52,9 +54,7 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
   int len = 0, pos = 0;
 
   Explanation *expl = expl_create(0.0,
-      epstrdup("weight(%s in %d), product of:",
-        strlen(query_str) + 20,
-        query_str, doc_num));
+      strfmt("weight(%s in %d), product of:", query_str, doc_num));
 
   for (i = 0; i < phq->t_cnt; i++) {
     len += strlen(phq->terms[i]->text) + 30;
@@ -69,14 +69,14 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
   doc_freqs[pos] = 0;
 
   Explanation *idf_expl1 = expl_create(self->idf,
-      epstrdup("idf(%s:<%s>)", strlen(phq->field) + pos, phq->field, doc_freqs));
+      strfmt("idf(%s:<%s>)", phq->field, doc_freqs));
   Explanation *idf_expl2 = expl_create(self->idf,
-      epstrdup("idf(%s:<%s>)", strlen(phq->field) + pos, phq->field, doc_freqs));
+      strfmt("idf(%s:<%s>)", phq->field, doc_freqs));
   free(doc_freqs);
   
   // explain query weight
   Explanation *query_expl = expl_create(0.0, 
-      epstrdup("query_weight(%s), product of:", strlen(query_str), query_str));
+      strfmt("query_weight(%s), product of:", query_str));
 
   if (self->query->boost != 1.0) {
     expl_add_detail(query_expl, expl_create(self->query->boost, estrdup("boost")));
@@ -92,8 +92,7 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
  
   // explain field weight
   Explanation *field_expl = expl_create(0.0, 
-      epstrdup("field_weight(%s in %d), product of:",
-        strlen(query_str) + 20, query_str, doc_num));
+      strfmt("field_weight(%s in %d), product of:", query_str, doc_num));
   free(query_str);
 
   Scorer *scorer = self->scorer(self, ir);
@@ -107,8 +106,7 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
     ? sim_decode_norm(self->similarity, field_norms[doc_num])
     : 0.0;
   Explanation *field_norm_expl = expl_create(field_norm,
-    epstrdup("field_norm(field=%s, doc=%d)",
-        strlen(phq->field) + 20, phq->field, doc_num));
+    strfmt("field_norm(field=%s, doc=%d)", phq->field, doc_num));
 
   expl_add_detail(field_expl, field_norm_expl);
 
@@ -127,9 +125,7 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
 
 char *phw_to_s(Weight *self)
 {
-  char dbuf[32];
-  dbl_to_s(dbuf, self->value);
-  return epstrdup("PhraseWeight(%s)", strlen(dbuf), dbuf);
+  return strfmt("PhraseWeight(%f)", self->value);
 }
 
 Weight *phw_create(Query *query, Searcher *searcher)
@@ -216,9 +212,8 @@ char *phq_to_s(Query *self, char *field)
     buf_index += strlen(buffer + buf_index);
   }
   if (self->boost != 1.0) {
-    char dbuf[32];
-    dbl_to_s(dbuf, self->boost);
-    sprintf(buffer + buf_index, "^%s", dbuf);
+    buffer[buf_index++] = '^';
+    dbl_to_s(buffer + buf_index, self->boost);
   }
   return buffer;
 }
@@ -270,7 +265,7 @@ void phq_add_term(Query *self, Term *term, int pos_inc)
   } else {
     position = phq->positions[index - 1] + pos_inc;
     if (strcmp(term->field, phq->field) != 0) {
-      eprintf(ARG_ERROR, "All phrase terms must be in the same field. Current phrase is %s, tried to add %s\n", phq->field, term->field);
+      RAISE(ARG_ERROR, FIELD_CHANGE_ERROR_MSG);
     }
   }
   phq->terms[index] = term;
@@ -356,7 +351,7 @@ bool pp_first_position(PhrasePosition *self)
 
 char *pp_to_s(PhrasePosition *self)
 {
-  return epstrdup("pp->(doc => %d, position => %d)", 40, self->doc, self->position);
+  return strfmt("pp->(doc => %d, position => %d)", self->doc, self->position);
 }
 
 inline int pp_cmp(const void *const p1, const void *const p2)
@@ -491,15 +486,13 @@ bool phsc_skip_to(Scorer *self, int doc_num)
 
 Explanation *phsc_explain(Scorer *self, int doc_num)
 {
-  char dbuf[32];
   GET_PHSC;
   while (phsc_next(self) && self->doc < doc_num)
     ;
 
   float phrase_freq = (self->doc == doc_num) ? phsc->freq : 0.0;
-  dbl_to_s(dbuf, phrase_freq);
   return expl_create(sim_tf(self->similarity, phrase_freq), 
-      epstrdup("tf(phrase_freq=%s)", strlen(dbuf), dbuf));
+      strfmt("tf(phrase_freq=%f)", phrase_freq));
 }
 
 void phsc_destroy(void *p)