ferret 0.9.1 → 0.9.2

data/ext/q_phrase.c

@@ -14,9 +14,13 @@ Scorer *phw_scorer(Weight *self, IndexReader *ir)
   Scorer *phsc;
   PhraseQuery *phq = (PhraseQuery *)self->query->data;
   int i;
-  if (phq->t_cnt == 0) return NULL; // optimize zero-term case
+  TermDocEnum **tps;
+  
+  if (phq->t_cnt == 0) {
+    return NULL; /* optimize zero-term case */
+  }
 
-  TermDocEnum **tps = ALLOC_N(TermDocEnum *, phq->t_cnt);
+  tps = ALLOC_N(TermDocEnum *, phq->t_cnt);
 
   for (i = 0; i < phq->t_cnt; i++) {
     tps[i] = ir_term_positions_for(ir, phq->terms[i]);
@@ -47,6 +51,17 @@ Scorer *phw_scorer(Weight *self, IndexReader *ir)
 
 Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
+  Explanation *idf_expl1;
+  Explanation *idf_expl2;
+  Explanation *query_expl;
+  Explanation *qnorm_expl;
+  Explanation *field_expl;
+  Explanation *tf_expl;
+  Scorer *scorer;
+  uchar *field_norms;
+  float field_norm;
+  Explanation *field_norm_expl;
+
   char *query_str = self->query->to_s(self->query, "");
   PhraseQuery *phq = (PhraseQuery *)self->query->data;
   int i;
@@ -57,25 +72,25 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int 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;
+    len += (int)strlen(phq->terms[i]->text) + 30;
   }
   doc_freqs = ALLOC_N(char, len);
   for (i = 0; i < phq->t_cnt; i++) {
     Term *term = phq->terms[i];
     sprintf(doc_freqs + pos, "%s=%d, ", term->text, ir->doc_freq(ir, term));
-    pos += strlen(doc_freqs + pos);
+    pos += (int)strlen(doc_freqs + pos);
   }
   pos -= 2; // remove ", " from the end
   doc_freqs[pos] = 0;
 
-  Explanation *idf_expl1 = expl_create(self->idf,
+  idf_expl1 = expl_create(self->idf,
       strfmt("idf(%s:<%s>)", phq->field, doc_freqs));
-  Explanation *idf_expl2 = expl_create(self->idf,
+  idf_expl2 = expl_create(self->idf,
       strfmt("idf(%s:<%s>)", phq->field, doc_freqs));
   free(doc_freqs);
   
-  // explain query weight
-  Explanation *query_expl = expl_create(0.0, 
+  /* explain query weight */
+  query_expl = expl_create(0.0, 
       strfmt("query_weight(%s), product of:", query_str));
 
   if (self->query->boost != 1.0) {
@@ -83,36 +98,36 @@ Explanation *phw_explain(Weight *self, IndexReader *ir, int doc_num)
   }
   expl_add_detail(query_expl, idf_expl1);
   
-  Explanation *qnorm_expl = expl_create(self->qnorm, estrdup("query_norm"));
+  qnorm_expl = expl_create(self->qnorm, estrdup("query_norm"));
   expl_add_detail(query_expl, qnorm_expl);
   
   query_expl->value = self->query->boost * self->idf * self->qnorm;
 
   expl_add_detail(expl, query_expl);
  
-  // explain field weight
-  Explanation *field_expl = expl_create(0.0, 
+  /* explain field weight */
+  field_expl = expl_create(0.0, 
       strfmt("field_weight(%s in %d), product of:", query_str, doc_num));
   free(query_str);
 
-  Scorer *scorer = self->scorer(self, ir);
-  Explanation *tf_expl = scorer->explain(scorer, doc_num);
+  scorer = self->scorer(self, ir);
+  tf_expl = scorer->explain(scorer, doc_num);
   scorer->destroy(scorer);
   expl_add_detail(field_expl, tf_expl);
   expl_add_detail(field_expl, idf_expl2);
 
-  uchar *field_norms = ir->get_norms(ir, phq->field);
-  float field_norm = (field_norms != NULL)
+  field_norms = ir->get_norms(ir, phq->field);
+  field_norm = (field_norms != NULL)
     ? sim_decode_norm(self->similarity, field_norms[doc_num])
-    : 0.0;
-  Explanation *field_norm_expl = expl_create(field_norm,
+    : (float)0.0;
+  field_norm_expl = expl_create(field_norm,
     strfmt("field_norm(field=%s, doc=%d)", phq->field, doc_num));
 
   expl_add_detail(field_expl, field_norm_expl);
 
   field_expl->value = tf_expl->value * self->idf * field_norm;
   
-  // combine them
+  /* combine them */
   if (query_expl->value == 1.0) {
     expl_destoy(expl);
     return field_expl;
@@ -130,20 +145,15 @@ char *phw_to_s(Weight *self)
 
 Weight *phw_create(Query *query, Searcher *searcher)
 {
+  Weight *self = w_create(query);
   PhraseQuery *phq = (PhraseQuery *)query->data;
-  Weight *self = ALLOC(Weight);
-  ZEROSET(self, Weight, 1);
-  self->get_query = &w_get_query;
-  self->get_value = &w_get_value;
-  self->normalize = &w_normalize;
+
   self->scorer    = &phw_scorer;
   self->explain   = &phw_explain;
   self->to_s      = &phw_to_s;
-  self->destroy   = &free;
   self->sum_of_squared_weights = &w_sum_of_squared_weights;
 
   self->similarity = query->get_similarity(query, searcher);
-  self->query = query;
   self->value = query->boost;
   self->idf = sim_idf_phrase(self->similarity, phq->terms, phq->t_cnt, searcher);
 
@@ -158,12 +168,12 @@ Weight *phw_create(Query *query, Searcher *searcher)
 
 #define GET_PHQ PhraseQuery *phq = (PhraseQuery *)self->data
 
-void phq_extract_terms(Query *self, Array *terms)
+void phq_extract_terms(Query *self, HashSet *terms)
 {
   GET_PHQ;
   int i;
   for (i = 0; i < phq->t_cnt; i++) {
-    ary_append(terms, phq->terms[i]);
+    hs_add(terms, term_clone(phq->terms[i]));
   }
 }
 
@@ -173,9 +183,9 @@ char *phq_to_s(Query *self, char *field)
   int i, j, buf_index = 0, len = 0, pos, last_pos = -1;
   char *buffer;
   if (!phq->t_cnt) return NULL;
-  len = strlen(phq->field) + 1;
+  len = (int)strlen(phq->field) + 1;
   for (i = 0; i < phq->t_cnt; i++) {
-    len += strlen(phq->terms[i]->text) + 1;
+    len += (int)strlen(phq->terms[i]->text) + 1;
   }
   // add space for extra characters and boost and slop
   len += 100 + 3 * phq->positions[phq->t_cnt - 1];
@@ -183,7 +193,7 @@ char *phq_to_s(Query *self, char *field)
   buffer = ALLOC_N(char, len);
 
   if (strcmp(field, phq->field) != 0) {
-    len = strlen(phq->field);
+    len = (int)strlen(phq->field);
     memcpy(buffer, phq->field, len);
     buffer[len] = ':';
     buf_index += len + 1;
@@ -199,7 +209,7 @@ char *phq_to_s(Query *self, char *field)
     }
     last_pos = pos;
 
-    len = strlen(term->text);
+    len = (int)strlen(term->text);
     memcpy(buffer + buf_index, term->text, len);
     buf_index += len;
     buffer[buf_index++] = ' ';
@@ -209,7 +219,7 @@ char *phq_to_s(Query *self, char *field)
   buffer[buf_index] = 0;
   if (phq->slop != 0) {
     sprintf(buffer + buf_index, "~%d", phq->slop);
-    buf_index += strlen(buffer + buf_index);
+    buf_index += (int)strlen(buffer + buf_index);
   }
   if (self->boost != 1.0) {
     buffer[buf_index++] = '^';
@@ -218,10 +228,8 @@ char *phq_to_s(Query *self, char *field)
   return buffer;
 }
 
-void phq_destroy(void *p)
+void phq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
-
   GET_PHQ;
   int i;
   if (self->destroy_all) {
@@ -233,7 +241,7 @@ void phq_destroy(void *p)
   free(phq->positions);
   free(phq);
 
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
 Query *phq_rewrite(Query *self, IndexReader *ir)
@@ -243,9 +251,9 @@ Query *phq_rewrite(Query *self, IndexReader *ir)
     Term *term = phq->terms[0];
     Query *tq = tq_create(term_clone(term));
     tq->boost = self->boost;
-    if (self->rewritten) self->rewritten->destroy(self->rewritten);
-    return self->rewritten = tq;
+    return tq;
   } else {
+    self->ref_cnt++;
     return self;
   }
 }
@@ -273,22 +281,48 @@ void phq_add_term(Query *self, Term *term, int pos_inc)
   phq->t_cnt++;
 }
 
+static uint phq_hash(Query *self)
+{
+  int i;
+  uint hash = 0;
+  PhraseQuery *phq = (PhraseQuery *)self->data;
+  for (i = 0; i < phq->t_cnt; i++) {
+    hash = (hash << 1) ^ (term_hash(phq->terms[i]) ^ phq->positions[i]);
+  }
+  return (hash ^ phq->slop);
+}
+
+static int phq_eq(Query *self, Query *o)
+{
+  int i;
+  PhraseQuery *phq1 = (PhraseQuery *)self->data;
+  PhraseQuery *phq2 = (PhraseQuery *)o->data;
+  if (phq1->slop != phq2->slop) return false;
+  for (i = 0; i < phq1->t_cnt; i++) {
+    if (!term_eq(phq1->terms[i], phq2->terms[i]) ||
+        (phq1->positions[i] != phq2->positions[i])) return false;
+  }
+  return true;
+}
+
 Query *phq_create()
 {
   Query *self = q_create();
-  PhraseQuery *phq = ALLOC(PhraseQuery);
-  ZEROSET(phq, PhraseQuery, 1);
+  PhraseQuery *phq = ALLOC_AND_ZERO_N(PhraseQuery, 1);
+
   phq->t_capa = PHQ_INIT_CAPA;
   phq->terms = ALLOC_N(Term *, PHQ_INIT_CAPA);
   phq->positions = ALLOC_N(int, PHQ_INIT_CAPA);
   self->data = phq;
 
-  self->create_weight = &phw_create;
+  self->type = PHRASE_QUERY;
+  self->rewrite = &phq_rewrite;
   self->extract_terms = &phq_extract_terms;
   self->to_s = &phq_to_s;
-  self->destroy = &phq_destroy;
-  self->rewrite = &phq_rewrite;
-  self->type = PHRASE_QUERY;
+  self->hash = &phq_hash;
+  self->eq = &phq_eq;
+  self->destroy_i = &phq_destroy;
+  self->create_weight_i = &phw_create;
   return self;
 }
 
@@ -376,9 +410,8 @@ bool pp_less_than(void *p1, void *p2)
   }
 }
 
-void pp_destroy(void *p)
+void pp_destroy(PhrasePosition *pp)
 {
-  PhrasePosition *pp = (PhrasePosition *)p;
   if (pp->tpe) pp->tpe->close(pp->tpe);
   free(pp);
 }
@@ -396,7 +429,7 @@ PhrasePosition *pp_create(TermDocEnum *tpe, int offset)
  * PhraseScorer
  ***************************************************************************/
 
-#define GET_PHSC PhraseScorer *phsc = (PhraseScorer *)self->data;
+#define GET_PHSC PhraseScorer *phsc = (PhraseScorer *)self->data
 
 
 void phsc_init(PhraseScorer *phsc)
@@ -484,27 +517,28 @@ bool phsc_skip_to(Scorer *self, int doc_num)
   return phsc_do_next(self);
 }
 
-Explanation *phsc_explain(Scorer *self, int doc_num)
+static Explanation *phsc_explain(Scorer *self, int doc_num)
 {
   GET_PHSC;
+  float phrase_freq;
+
   while (phsc_next(self) && self->doc < doc_num)
     ;
 
-  float phrase_freq = (self->doc == doc_num) ? phsc->freq : 0.0;
+  phrase_freq = (self->doc == doc_num) ? phsc->freq : (float)0.0;
   return expl_create(sim_tf(self->similarity, phrase_freq), 
       strfmt("tf(phrase_freq=%f)", phrase_freq));
 }
 
-void phsc_destroy(void *p)
+static void phsc_destroy(Scorer *self)
 {
-  Scorer *self = (Scorer *)p;
   GET_PHSC;
   int i;
   for (i = phsc->pp_cnt - 1; i >= 0; i--) {
     pp_destroy(phsc->phrase_pos[i]);
   }
   free(phsc->phrase_pos);
-  scorer_destroy(self);
+  scorer_destroy_i(self);
 }
 
 Scorer *phsc_create(Weight *weight, TermDocEnum **term_pos_enum,

data/ext/q_prefix.c

@@ -11,8 +11,8 @@ 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);
+  size_t tlen = strlen(term->text);
+  size_t flen = strlen(term->field);
   bptr = buffer = ALLOC_N(char, tlen + flen + 35);
 
   if (strcmp(term->field, field) != 0) {
@@ -33,7 +33,7 @@ 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);
+  size_t prefix_length = strlen(prefix_text);
   char *prefix_field = prefix->field;
   Query *tq;
   Query *bq = bq_create(true);
@@ -45,34 +45,45 @@ Query *prq_rewrite(Query *self, IndexReader *ir)
         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
+      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));
   XFINALLY
     te->close(te);
   XENDTRY
 
-  if (self->rewritten) self->rewritten->destroy(self->rewritten);
-  return self->rewritten = bq;
+  return bq;
 }
 
-void prq_destroy(void *p)
+static void prq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   if (self->destroy_all) term_destroy((Term *)self->data);
-  q_destroy(self);
+  q_destroy_i(self);
+}
+
+static uint prq_hash(Query *self)
+{
+  return term_hash((Term *)self->data);
+}
+
+static int prq_eq(Query *self, Query *o)
+{
+  return term_eq((Term *)self->data, (Term *)o->data);
 }
 
 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;
+  self->to_s = &prq_to_s;
+  self->hash = &prq_hash;
+  self->eq = &prq_eq;
+  self->destroy_i = &prq_destroy;
+  self->create_weight_i = &q_create_weight_unsup;
 
   return self;
 }

data/ext/q_range.c

@@ -15,7 +15,7 @@ static char * const BOUND_ORDER_ERROR_MSG = "The lower bound must less than the
 char *range_to_s(Range *range, char *field, float boost)
 {
   char *buffer, *b;
-  int flen, llen, ulen;
+  size_t flen, llen, ulen;
 
   flen = strlen(range->field);
   llen = range->lower_term ? strlen(range->lower_term) : 0;
@@ -71,6 +71,28 @@ void range_destroy(void *p)
   free(range);
 }
 
+static inline uint range_hash(Range *self)
+{
+  return self->include_lower | (self->include_upper << 1) |
+      ((str_hash(self->field) ^
+        (self->lower_term ? str_hash(self->lower_term) : 0) ^
+        (self->upper_term ? str_hash(self->upper_term) : 0)) << 2);
+}
+
+static inline int str_eq(char *s1, char *s2)
+{
+  return (s1 && s2 && (strcmp(s1, s2) == 0)) || (s1 == s2);
+}
+
+static inline int range_eq(Range *self, Range *o)
+{
+  return (str_eq(self->field, o->field) &&
+          str_eq(self->lower_term, o->lower_term) &&
+          str_eq(self->upper_term, o->upper_term) &&
+          (self->include_lower == o->include_lower) &&
+          (self->include_upper == o->include_upper));
+}
+
 Range *range_create(const char *field, char *lower_term, char *upper_term,
     bool include_lower, bool include_upper)
 {
@@ -101,9 +123,8 @@ Range *range_create(const char *field, char *lower_term, char *upper_term,
  *
  ***************************************************************************/
 
-void rfilt_destroy(void *p)
+void rfilt_destroy(Filter *self)
 {
-  Filter *self = (Filter *)p;
   range_destroy(self->data);
   filt_destroy(self);
 }
@@ -111,7 +132,10 @@ void rfilt_destroy(void *p)
 char *rfilt_to_s(Filter *self)
 {
   Range *range = (Range *)self->data;
-  return range_to_s(range, "", 1.0);
+  char *rstr = range_to_s(range, "", 1.0);
+  char *rfstr = epstrdup("RangeFilter< %s >", strlen(rstr), rstr);
+  free(rstr);
+  return rfstr;
 }
 
 BitVector *rfilt_get_bv(Filter *self, IndexReader *ir)
@@ -177,6 +201,16 @@ BitVector *rfilt_get_bv(Filter *self, IndexReader *ir)
   return bv;
 }
 
+uint rfilt_hash(Filter *self)
+{
+  return range_hash((Range *)self->data);
+}
+
+int rfilt_eq(Filter *self, Filter *o)
+{
+  return range_eq((Range *)self->data, (Range *)o->data);
+}
+
 Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
     bool include_lower, bool include_upper)
 {
@@ -187,6 +221,8 @@ Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
   self = filt_create("RangeFilter");
   self->data = range;
   self->get_bv = &rfilt_get_bv;
+  self->hash = &rfilt_hash;
+  self->eq = &rfilt_eq;
   self->to_s = &rfilt_to_s;
   self->destroy = &rfilt_destroy;
   return self;
@@ -204,11 +240,10 @@ char *rq_to_s(Query *self, char *field)
   return range_to_s(range, field, self->boost);
 }
 
-void rq_destroy(void *p)
+void rq_destroy(Query *self)
 {
-  Query *self = (Query *)p;
   range_destroy(self->data);
-  q_destroy(self);
+  q_destroy_i(self);
 }
 
 Query *rq_rewrite(Query *self, IndexReader *ir)
@@ -216,8 +251,17 @@ 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);
+  return csq_create(filter);
+}
+
+static uint rq_hash(Query *self)
+{
+  return range_hash((Range *)self->data);
+}
+
+static int rq_eq(Query *self, Query *o)
+{
+  return range_eq((Range *)self->data, (Range *)o->data);
 }
 
 Query *rq_create_less(const char *field, char *upper_term, bool include_upper)
@@ -233,17 +277,18 @@ Query *rq_create_more(const char *field, char *lower_term, bool include_lower)
 Query *rq_create(const char *field, char *lower_term, char *upper_term,
     bool include_lower, bool include_upper)
 {
-  Query *self;
+  Query *self = q_create();
   Range *range = range_create(field, lower_term, upper_term,
       include_lower, include_upper); 
 
-  self = q_create();
+  self->data = range;
 
   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;
+  self->hash = &rq_hash;
+  self->eq = &rq_eq;
+  self->destroy_i = &rq_destroy;
+  self->create_weight_i = &q_create_weight_unsup;
   return self;
 }