ferret 0.9.6 → 0.10.0

data/ext/q_const_score.c

@@ -3,146 +3,159 @@
 
 /***************************************************************************
  *
- * Weight
+ * ConstantScoreScorer
  *
  ***************************************************************************/
 
-char *csw_to_s(Weight *self)
+#define CScQ(query) ((ConstantScoreQuery *)(query))
+#define CScSc(scorer) ((ConstantScoreScorer *)(scorer))
+
+typedef struct ConstantScoreScorer
+{
+    Scorer      super;
+    BitVector  *bv;
+    float       score;
+} ConstantScoreScorer;
+
+static float cssc_score(Scorer *self)
 {
-  return strfmt("ConstantScoreWeight(%f)", self->value);
+    return CScSc(self)->score;
 }
 
-Explanation *csw_explain(Weight *self, IndexReader *ir, int doc_num)
+static bool cssc_next(Scorer *self)
 {
-  Filter *filter = (Filter *)self->query->data;
-  Explanation *expl;
-  char *filter_str = filter->to_s(filter);
-  BitVector *bv = filt_get_bv(filter, ir);
-
-  if (bv_get(bv, doc_num)) {
-    expl = expl_create(self->value,
-        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,
-        strfmt("ConstantScoreQuery(%s), does not match id %d",
-          filter_str, doc_num));
-  }
-  free(filter_str);
-  return expl;
+    return ((self->doc = bv_scan_next(CScSc(self)->bv)) >= 0);
 }
 
-Weight *csw_create(Query *query, Searcher *searcher)
+static bool cssc_skip_to(Scorer *self, int doc_num)
 {
-  Weight *self = w_create(query);
-  self->scorer    = &cssc_create;
-  self->explain   = &csw_explain;
-  self->to_s      = &csw_to_s;
-  self->sum_of_squared_weights = &w_sum_of_squared_weights;
+    return ((self->doc = bv_scan_next_from(CScSc(self)->bv, doc_num)) >= 0);
+}
 
-  self->similarity = query->get_similarity(query, searcher);
-  self->idf = 1.0;
+static Explanation *cssc_explain(Scorer *self, int doc_num)
+{
+    (void)self; (void)doc_num;
+    return expl_new(1.0, "ConstantScoreScorer");
+}
 
-  return self;
+static Scorer *cssc_new(Weight *weight, IndexReader *ir)
+{
+    Scorer *self    = scorer_new(ConstantScoreScorer, weight->similarity);
+    Filter *filter  = CScQ(weight->query)->filter;
+
+    CScSc(self)->score  = weight->value;
+    CScSc(self)->bv     = filt_get_bv(filter, ir);
+
+    self->score     = &cssc_score;
+    self->next      = &cssc_next;
+    self->skip_to   = &cssc_skip_to;
+    self->explain   = &cssc_explain;
+    self->destroy   = &scorer_destroy_i;
+    return self;
 }
 
 /***************************************************************************
  *
- * ConstantScoreQuery
+ * ConstantScoreWeight
  *
  ***************************************************************************/
 
-char *csq_to_s(Query *self, char *field)
+static char *csw_to_s(Weight *self)
 {
-  Filter *filter = (Filter *)self->data;
-  char *filter_str = filter->to_s(filter);
-  char *buffer;
-  if (self->boost == 1.0) {
-    buffer = strfmt("ConstantScore(%s)", filter_str);
-  } else {
-    buffer = strfmt("ConstantScore(%s)^%f", filter_str, self->boost);
-  }
-  free(filter_str);
-  return buffer;;
+    return strfmt("ConstantScoreWeight(%f)", self->value);
 }
 
-void csq_destroy(Query *self)
+static Explanation *csw_explain(Weight *self, IndexReader *ir, int doc_num)
 {
-  if (self->destroy_all) {
-    Filter *filter = (Filter *)self->data;
-    filter->destroy(filter);
-  }
-  q_destroy_i(self);
+    Filter *filter = CScQ(self->query)->filter;
+    Explanation *expl;
+    char *filter_str = filter->to_s(filter);
+    BitVector *bv = filt_get_bv(filter, ir);
+
+    if (bv_get(bv, doc_num)) {
+        expl = expl_new(self->value,
+                        "ConstantScoreQuery(%s), product of:", filter_str);
+        expl_add_detail(expl, expl_new(self->query->boost, "boost"));
+        expl_add_detail(expl, expl_new(self->qnorm, "query_norm"));
+    }
+    else {
+        expl = expl_new(self->value,
+                        "ConstantScoreQuery(%s), does not match id %d",
+                        filter_str, doc_num);
+    }
+    free(filter_str);
+    return expl;
 }
 
-static uint csq_hash(Query *self)
+static Weight *csw_new(Query *query, Searcher *searcher)
 {
-  return filt_hash((Filter *)self->data);
-}
+    Weight *self        = w_new(Weight, query);
 
-static int csq_eq(Query *self, Query *o)
-{
-  return filt_eq((Filter *)self->data, (Filter *)o->data);
-}
-
-Query *csq_create(Filter *filter)
-{
-  Query *self = q_create();
-  self->data = filter;
+    self->scorer        = &cssc_new;
+    self->explain       = &csw_explain;
+    self->to_s          = &csw_to_s;
 
-  self->type = CONSTANT_QUERY;
-  self->to_s = &csq_to_s;
-  self->hash = &csq_hash;
-  self->eq = &csq_eq;
-  self->destroy_i = &csq_destroy;
-  self->create_weight_i = &csw_create;
+    self->similarity    = query->get_similarity(query, searcher);
+    self->idf           = 1.0;
 
-  return self;
+    return self;
 }
 
 /***************************************************************************
  *
- * ConstantScoreScorer
+ * ConstantScoreQuery
  *
  ***************************************************************************/
 
-float cssc_score(Scorer *self)
+static char *csq_to_s(Query *self, const char *field)
 {
-  return ((ConstantScoreScorer *)self->data)->score;
+    Filter *filter = CScQ(self)->filter;
+    char *filter_str = filter->to_s(filter);
+    char *buffer;
+    (void)field;
+    if (self->boost == 1.0) {
+        buffer = strfmt("ConstantScore(%s)", filter_str);
+    }
+    else {
+        buffer = strfmt("ConstantScore(%s)^%f", filter_str, self->boost);
+    }
+    free(filter_str);
+    return buffer;;
 }
 
-bool cssc_next(Scorer *self)
+static void csq_destroy(Query *self)
 {
-  BitVector *bv = ((ConstantScoreScorer *)self->data)->bv;
-  return ((self->doc = bv_scan_next(bv)) >= 0);
+    filt_deref(CScQ(self)->filter);
+    q_destroy_i(self);
 }
 
-bool cssc_skip_to(Scorer *self, int doc_num)
+static ulong csq_hash(Query *self)
 {
-  BitVector *bv = ((ConstantScoreScorer *)self->data)->bv;
-  return ((self->doc = bv_scan_next_from(bv, doc_num)) >= 0);
+    return filt_hash(CScQ(self)->filter);
 }
 
-Explanation *cssc_explain(Scorer *self, int doc_num)
+static int csq_eq(Query *self, Query *o)
 {
-  return expl_create(1.0, estrdup("ConstantScoreScorer"));
+    return filt_eq(CScQ(self)->filter, CScQ(o)->filter);
+}
+
+Query *csq_new_nr(Filter *filter)
+{
+    Query *self = q_new(ConstantScoreQuery);
+    CScQ(self)->filter = filter;
+
+    self->type              = CONSTANT_QUERY;
+    self->to_s              = &csq_to_s;
+    self->hash              = &csq_hash;
+    self->eq                = &csq_eq;
+    self->destroy_i         = &csq_destroy;
+    self->create_weight_i   = &csw_new;
+
+    return self;
 }
 
-Scorer *cssc_create(Weight *weight, IndexReader *ir)
+Query *csq_new(Filter *filter)
 {
-  Scorer *self = scorer_create(weight->similarity);
-  Filter *filter = (Filter *)weight->query->data;
-  ConstantScoreScorer *cssc = ALLOC(ConstantScoreScorer);
-  ZEROSET(cssc, ConstantScoreScorer, 1);
-  self->data = cssc;
-  cssc->score = weight->value;
-  cssc->bv = filt_get_bv(filter, ir);
-
-  self->score = &cssc_score;
-  self->next = &cssc_next;
-  self->skip_to = &cssc_skip_to;
-  self->explain = &cssc_explain;
-  self->destroy = &scorer_destroy_i;
-  return self;
+    REF(filter);
+    return csq_new_nr(filter);
 }

data/ext/q_filtered_query.c

@@ -1,206 +1,209 @@
 #include "search.h"
 #include <string.h>
 
-Scorer *fqsc_create(Scorer *scorer, BitVector *bv, Similarity *sim);
-
 /***************************************************************************
  *
- * Weight
+ * FilteredQueryScorer
  *
  ***************************************************************************/
 
-char *fqw_to_s(Weight *self)
-{
-  return strfmt("FilteredQueryWeight(%f)", self->value);
-}
+#define FQSc(scorer) ((FilteredQueryScorer *)(scorer))
+#define FQQ(query) ((FilteredQuery *)(query))
 
-float fqw_sum_of_squared_weights(Weight *self)
+typedef struct FilteredQueryScorer
 {
-  Weight *sw = (Weight *)self->data;
-  return sw->sum_of_squared_weights(sw);
-}
+    Scorer      super;
+    Scorer     *sub_scorer;
+    BitVector  *bv;
+} FilteredQueryScorer;
 
-void fqw_normalize(Weight *self, float normalization_factor)
+float fqsc_score(Scorer *self)
 {
-  Weight *sw = (Weight *)self->data;
-  sw->normalize(sw, normalization_factor);
+    Scorer *sub_sc = FQSc(self)->sub_scorer;
+    return sub_sc->score(sub_sc);
 }
 
-float fqw_get_value(Weight *self)
+bool fqsc_next(Scorer *self)
 {
-  Weight *sw = (Weight *)self->data;
-  return sw->get_value(sw);
+    Scorer *sub_sc = FQSc(self)->sub_scorer;
+    BitVector *bv = FQSc(self)->bv;
+    while (sub_sc->next(sub_sc)) {
+        self->doc = sub_sc->doc;
+        if (bv_get(bv, self->doc)) return true;
+    }
+    return false;
 }
 
-Explanation *fqw_explain(Weight *self, IndexReader *ir, int doc_num)
+bool fqsc_skip_to(Scorer *self, int doc_num)
 {
-  Weight *sw = (Weight *)self->data;
-  return sw->explain(sw, ir, doc_num);
+    Scorer *sub_sc = FQSc(self)->sub_scorer;
+    BitVector *bv = FQSc(self)->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;
 }
 
-Scorer *fqw_scorer(Weight *self, IndexReader *ir)
+Explanation *fqsc_explain(Scorer *self, int doc_num)
 {
-  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);
+    Scorer *sub_sc = FQSc(self)->sub_scorer;
+    return sub_sc->explain(sub_sc, doc_num);
 }
 
-void fqw_destroy(Weight *self)
+void fqsc_destroy(Scorer *self)
 {
-  Weight *sw = (Weight *)self->data;
-  sw->destroy(sw);
-  w_destroy(self);
+    FilteredQueryScorer *fqsc = FQSc(self);
+    fqsc->sub_scorer->destroy(fqsc->sub_scorer);
+    scorer_destroy_i(self);
 }
 
-Weight *fqw_create(Query *query, Weight *sub_weight, Similarity *sim)
+Scorer *fqsc_new(Scorer *scorer, BitVector *bv, Similarity *sim)
 {
-  Weight *self = w_create(query);
-
-  self->data = sub_weight;
+    Scorer *self            = scorer_new(FilteredQueryScorer, sim);
 
-  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;
+    FQSc(self)->sub_scorer  = scorer;
+    FQSc(self)->bv          = bv;
 
-  self->similarity = sim;
-  self->idf = 1.0;
-  self->value = sub_weight->value;
+    self->score   = &fqsc_score;
+    self->next    = &fqsc_next;
+    self->skip_to = &fqsc_skip_to;
+    self->explain = &fqsc_explain;
+    self->destroy = &fqsc_destroy;
 
-  return self;
+    return self;
 }
 
 /***************************************************************************
  *
- * FilteredQueryQuery
+ * Weight
  *
  ***************************************************************************/
 
-char *fq_to_s(Query *self, char *field)
+#define FQW(weight) ((FilteredQueryWeight *)(weight))
+typedef struct FilteredQueryWeight
 {
-  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;;
+    Weight  super;
+    Weight *sub_weight;
+} FilteredQueryWeight;
+
+static char *fqw_to_s(Weight *self)
+{
+    return strfmt("FilteredQueryWeight(%f)", self->value);
 }
 
-void fq_destroy(Query *self)
+static float fqw_sum_of_squared_weights(Weight *self)
 {
-  if (self->destroy_all) {
-    FilteredQuery *fq = (FilteredQuery *)self->data;
-    fq->filter->destroy(fq->filter);
-    q_deref(fq->query);
-  }
-  free(self->data);
-  q_destroy_i(self);
+    Weight *sub_weight = FQW(self)->sub_weight;
+    return sub_weight->sum_of_squared_weights(sub_weight);
 }
 
-Weight *fq_create_weight(Query *self, Searcher *searcher)
+static void fqw_normalize(Weight *self, float normalization_factor)
 {
-  Query *sub_query = ((FilteredQuery *)self->data)->query;
-  return fqw_create(self, q_weight(sub_query, searcher),
-      searcher->similarity);
+    Weight *sub_weight = FQW(self)->sub_weight;
+    sub_weight->normalize(sub_weight, normalization_factor);
 }
 
-Query *fq_create(Query *query, Filter *filter)
+static float fqw_get_value(Weight *self)
 {
-  Query *self = q_create();
+    Weight *sub_weight = FQW(self)->sub_weight;
+    return sub_weight->get_value(sub_weight);
+}
 
-  FilteredQuery *fq = ALLOC(FilteredQuery);
-  fq->query = query;
-  fq->filter = filter;
-  self->data = fq;
+static Explanation *fqw_explain(Weight *self, IndexReader *ir, int doc_num)
+{
+    Weight *sub_weight = FQW(self)->sub_weight;
+    return sub_weight->explain(sub_weight, ir, doc_num);
+}
 
-  self->type = FILTERED_QUERY;
-  self->to_s = &fq_to_s;
-  self->destroy_i = &fq_destroy;
-  self->create_weight_i = &fq_create_weight;
+static Scorer *fqw_scorer(Weight *self, IndexReader *ir)
+{
+    Weight *sub_weight = FQW(self)->sub_weight;
+    Scorer *scorer = sub_weight->scorer(sub_weight, ir);
+    Filter *filter = FQQ(self->query)->filter;
 
-  return self;
+    return fqsc_new(scorer, filt_get_bv(filter, ir), self->similarity);
+}
+
+static void fqw_destroy(Weight *self)
+{
+    Weight *sub_weight = FQW(self)->sub_weight;
+    sub_weight->destroy(sub_weight);
+    w_destroy(self);
+}
+
+static Weight *fqw_new(Query *query, Weight *sub_weight, Similarity *sim)
+{
+    Weight *self = w_new(FilteredQueryWeight, query);
+
+    FQW(self)->sub_weight           = sub_weight;
+
+    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->value                     = sub_weight->value;
+
+    return self;
 }
 
 /***************************************************************************
  *
- * FilteredQueryScorer
+ * FilteredQuery
  *
  ***************************************************************************/
 
-typedef struct FilteredQueryScorer {
-  Scorer *sub_scorer;
-  BitVector *bv;
-} FilteredQueryScorer;
-
-float fqsc_score(Scorer *self)
+static char *fq_to_s(Query *self, const char *field)
 {
-  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
-  return sub_sc->score(sub_sc);
+    FilteredQuery *fq = FQQ(self);
+    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;;
 }
 
-bool fqsc_next(Scorer *self)
+void fq_destroy(Query *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;
+    filt_deref(FQQ(self)->filter);
+    q_deref(FQQ(self)->query);
+    q_destroy_i(self);
 }
 
-bool fqsc_skip_to(Scorer *self, int doc_num)
+Weight *fq_new_weight(Query *self, Searcher *searcher)
 {
-  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;
+    Query *sub_query = FQQ(self)->query;
+    return fqw_new(self, q_weight(sub_query, searcher),
+                      searcher->similarity);
 }
 
-Explanation *fqsc_explain(Scorer *self, int doc_num)
+Query *fq_new(Query *query, Filter *filter)
 {
-  Scorer *sub_sc = ((FilteredQueryScorer *)self->data)->sub_scorer;
-  return sub_sc->explain(sub_sc, doc_num);
-}
+    Query *self = q_new(FilteredQuery);
 
-void fqsc_destroy(Scorer *self)
-{
-  FilteredQueryScorer *fqsc = (FilteredQueryScorer *)self->data;
-  bv_destroy(fqsc->bv);
-  fqsc->sub_scorer->destroy(fqsc->sub_scorer);
-  scorer_destroy_i(self);
-}
+    FQQ(self)->query        = query;
+    FQQ(self)->filter       = filter;
 
-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->type              = FILTERED_QUERY;
+    self->to_s              = &fq_to_s;
+    self->destroy_i         = &fq_destroy;
+    self->create_weight_i   = &fq_new_weight;
 
-  self->score = &fqsc_score;
-  self->next = &fqsc_next;
-  self->skip_to = &fqsc_skip_to;
-  self->explain = &fqsc_explain;
-  self->destroy = &fqsc_destroy;
-  return self;
+    return self;
 }