ferret 0.9.6 → 0.10.0

data/ext/q_prefix.c

@@ -7,83 +7,94 @@
  *
  ****************************************************************************/
 
-char *prq_to_s(Query *self, char *field) 
+#define PfxQ(query) ((PrefixQuery *)(query))
+
+static char *prq_to_s(Query *self, const char *current_field) 
 {
-  char *buffer, *bptr;
-  Term *term = (Term *)self->data;
-  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) {
-    sprintf(bptr, "%s:", term->field);
-    bptr += strlen(bptr);
-  }
-  sprintf(bptr, "%s*", term->text);
-  if (self->boost != 1.0) {
-    *bptr = '^';
-    dbl_to_s(++bptr, self->boost);
-  }
-
-  return buffer;
+    char *buffer, *bptr;
+    const char *prefix = PfxQ(self)->prefix;
+    const char *field = PfxQ(self)->field;
+    size_t plen = strlen(prefix);
+    size_t flen = strlen(field);
+
+    bptr = buffer = ALLOC_N(char, plen + flen + 35);
+
+    if (strcmp(field, current_field) != 0) {
+        sprintf(bptr, "%s:", field);
+        bptr += flen + 1;
+    }
+
+    sprintf(bptr, "%s*", prefix);
+    bptr += plen + 1;
+    if (self->boost != 1.0) {
+        *bptr = '^';
+        dbl_to_s(++bptr, self->boost);
+    }
+
+    return buffer;
 }
 
-Query *prq_rewrite(Query *self, IndexReader *ir)
+static Query *prq_rewrite(Query *self, IndexReader *ir)
 {
-  Term *prefix = (Term *)self->data;
-  TermEnum *te = ir->terms_from(ir, prefix);
-  char *prefix_text = prefix->text;
-  size_t prefix_length = strlen(prefix_text);
-  char *prefix_field = prefix->field;
-  Query *tq;
-  Query *bq = bq_create(true);
-
-  TRY
-    do { 
-      TermBuffer *tb = te->tb_curr;
-      if (!tb || strcmp(tb->field, prefix_field) != 0 ||
-        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  */
-    } while (te->next(te));
-  XFINALLY
-    te->close(te);
-  XENDTRY
-
-  return bq;
+    const char *field = PfxQ(self)->field;
+    const int field_num = fis_get_field_num(ir->fis, field);
+    Query *volatile q = multi_tq_new_conf(field, MTQMaxTerms(self), 0.0);
+    q->boost = self->boost;        /* set the boost */
+
+    if (field_num >= 0) {
+        const char *prefix = PfxQ(self)->prefix;
+        TermEnum *te = ir->terms_from(ir, field_num, prefix);
+        const char *term = te->curr_term;
+        size_t prefix_len = strlen(prefix);
+
+        TRY
+            do { 
+                if (strncmp(term, prefix, prefix_len) != 0) {
+                    break;
+                }
+                multi_tq_add_term(q, term);       /* found a match */
+            } while (te->next(te));
+        XFINALLY
+            te->close(te);
+        XENDTRY
+    }
+
+    return q;
 }
 
 static void prq_destroy(Query *self)
 {
-  if (self->destroy_all) term_destroy((Term *)self->data);
-  q_destroy_i(self);
+    free(PfxQ(self)->field);
+    free(PfxQ(self)->prefix);
+    q_destroy_i(self);
 }
 
-static uint prq_hash(Query *self)
+static ulong prq_hash(Query *self)
 {
-  return term_hash((Term *)self->data);
+    return str_hash(PfxQ(self)->field) ^ str_hash(PfxQ(self)->prefix);
 }
 
 static int prq_eq(Query *self, Query *o)
 {
-  return term_eq((Term *)self->data, (Term *)o->data);
+    return (strcmp(PfxQ(self)->prefix, PfxQ(o)->prefix) == 0) 
+        && (strcmp(PfxQ(self)->field,  PfxQ(o)->field) == 0);
 }
 
-Query *prefixq_create(Term *prefix)
+Query *prefixq_new(const char *field, const char *prefix)
 {
-  Query *self = q_create();
-  self->data = prefix;
-
-  self->type = PREFIX_QUERY;
-  self->rewrite = &prq_rewrite;
-  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;
+    Query *self = q_new(PrefixQuery);
+
+    PfxQ(self)->field       = estrdup(field);
+    PfxQ(self)->prefix      = estrdup(prefix);
+    MTQMaxTerms(self)       = PREFIX_QUERY_MAX_TERMS;
+
+    self->type              = PREFIX_QUERY;
+    self->rewrite           = &prq_rewrite;
+    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

@@ -1,120 +1,134 @@
 #include <string.h>
 #include "search.h"
 
-static char * const NIL_BOUNDS_ERROR_MSG = "At least one value must be non-nil";
-static char * const LOWER_BOUND_ERROR_MSG = "The lower bound must be non-nil to be inclusive";
-static char * const UPPER_BOUND_ERROR_MSG = "The upper bound must be non-nil to be inclusive";
-static char * const BOUND_ORDER_ERROR_MSG = "The lower bound must less than the upper bound";
-        
 /*****************************************************************************
  *
  * Range
  *
  *****************************************************************************/
 
-char *range_to_s(Range *range, char *field, float boost)
+typedef struct Range
 {
-  char *buffer, *b;
-  size_t flen, llen, ulen;
-
-  flen = strlen(range->field);
-  llen = range->lower_term ? strlen(range->lower_term) : 0;
-  ulen = range->upper_term ? strlen(range->upper_term) : 0;
-  buffer = ALLOC_N(char, flen + llen + ulen + 40);
-  b = buffer;
-
-  if (strcmp(field, range->field)) {
-    memcpy(buffer, range->field, flen * sizeof(char));
-    b += flen;
-    *b = ':';
-    b++;
-  }
-
-  if (range->lower_term) {
-    *b = range->include_lower ? '[' : '{';
-    b++;
-    memcpy(b, range->lower_term, llen);
-    b += llen;
-  } else {
-    *b = '<';
-    b++;
-  }
-
-  if (range->upper_term && range->lower_term) {
-    *b = ' '; b++;
-  }
-
-  if (range->upper_term) {
-    memcpy(b, range->upper_term, ulen);
-    b += ulen;
-    *b = range->include_upper ? ']' : '}';
-    b++;
-  } else {
-    *b = '>';
-    b++;
-  }
-
-  *b = 0;
-  if (boost != 1.0) {
-    *b = '^';
-    dbl_to_s(b + 1, boost);
-  }
-  return buffer;
+    char *field;
+    char *lower_term;
+    char *upper_term;
+    bool include_lower : 1;
+    bool include_upper : 1;
+} Range;
+
+static char *range_to_s(Range *range, const char *field, float boost)
+{
+    char *buffer, *b;
+    size_t flen, llen, ulen;
+
+    flen = strlen(range->field);
+    llen = range->lower_term ? strlen(range->lower_term) : 0;
+    ulen = range->upper_term ? strlen(range->upper_term) : 0;
+    buffer = ALLOC_N(char, flen + llen + ulen + 40);
+    b = buffer;
+
+    if (strcmp(field, range->field)) {
+        memcpy(buffer, range->field, flen * sizeof(char));
+        b += flen;
+        *b = ':';
+        b++;
+    }
+
+    if (range->lower_term) {
+        *b = range->include_lower ? '[' : '{';
+        b++;
+        memcpy(b, range->lower_term, llen);
+        b += llen;
+    } else {
+        *b = '<';
+        b++;
+    }
+
+    if (range->upper_term && range->lower_term) {
+        *b = ' '; b++;
+    }
+
+    if (range->upper_term) {
+        memcpy(b, range->upper_term, ulen);
+        b += ulen;
+        *b = range->include_upper ? ']' : '}';
+        b++;
+    } else {
+        *b = '>';
+        b++;
+    }
+
+    *b = 0;
+    if (boost != 1.0) {
+        *b = '^';
+        dbl_to_s(b + 1, boost);
+    }
+    return buffer;
 }
 
-void range_destroy(void *p)
+static void range_destroy(Range *range)
 {
-  Range *range = (Range *)p;
-  free(range->field);
-  if (range->lower_term) free(range->lower_term);
-  if (range->upper_term) free(range->upper_term);
-  free(range);
+    free(range->field);
+    free(range->lower_term);
+    free(range->upper_term);
+    free(range);
 }
 
-static inline uint range_hash(Range *self)
+static ulong range_hash(Range *filt)
 {
-  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);
+    return filt->include_lower | (filt->include_upper << 1)
+        | ((str_hash(filt->field)
+            ^ (filt->lower_term ? str_hash(filt->lower_term) : 0)
+            ^ (filt->upper_term ? str_hash(filt->upper_term) : 0)) << 2);
 }
 
-static inline int str_eq(char *s1, char *s2)
+static int str_eq(char *s1, char *s2)
 {
-  return (s1 && s2 && (strcmp(s1, s2) == 0)) || (s1 == s2);
+    return (s1 && s2 && (strcmp(s1, s2) == 0)) || (s1 == s2);
 }
 
-static inline int range_eq(Range *self, Range *o)
+static int range_eq(Range *filt, 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));
+    return (str_eq(filt->field, o->field)
+            && str_eq(filt->lower_term, o->lower_term)
+            && str_eq(filt->upper_term, o->upper_term)
+            && (filt->include_lower == o->include_lower)
+            && (filt->include_upper == o->include_upper));
 }
 
-Range *range_create(const char *field, char *lower_term, char *upper_term,
-    bool include_lower, bool include_upper)
+Range *range_new(const char *field, const char *lower_term,
+                 const char *upper_term, bool include_lower,
+                 bool include_upper)
 {
-  Range *range; 
-
-  if (!lower_term && !upper_term) 
-    RAISE(ARG_ERROR, NIL_BOUNDS_ERROR_MSG);
-  if (include_lower && !lower_term) 
-    RAISE(ARG_ERROR, LOWER_BOUND_ERROR_MSG);
-  if (include_upper && !upper_term) 
-    RAISE(ARG_ERROR, UPPER_BOUND_ERROR_MSG);
-  if (upper_term && lower_term && (strcmp(upper_term, lower_term) < 0))
-    RAISE(ARG_ERROR, BOUND_ORDER_ERROR_MSG);
-
-  range = ALLOC(Range);
-
-  range->field = estrdup((char *)field);
-  range->lower_term = lower_term ? estrdup(lower_term) : NULL;
-  range->upper_term = upper_term ? estrdup(upper_term) : NULL;
-  range->include_lower = include_lower;
-  range->include_upper = include_upper;
-  return range;
+    Range *range; 
+
+    if (!lower_term && !upper_term) {
+        RAISE(ARG_ERROR, "Nil bounds for range. A range must include either "
+              "lower bound or an upper bound");
+    }
+    if (include_lower && !lower_term) {
+        RAISE(ARG_ERROR, "Lower bound must be non-nil to be inclusive. That "
+              "is, if you specify :include_lower => true when you create a "
+              "range you must include a :lower_term");
+    }
+    if (include_upper && !upper_term) {
+        RAISE(ARG_ERROR, "Upper bound must be non-nil to be inclusive. That "
+              "is, if you specify :include_upper => true when you create a "
+              "range you must include a :upper_term");
+    }
+    if (upper_term && lower_term && (strcmp(upper_term, lower_term) < 0)) {
+        RAISE(ARG_ERROR, "Upper bound must be greater than lower bound. "
+              "\"%s\" < \"%s\"", upper_term, lower_term);
+    }
+
+    range = ALLOC(Range);
+
+    range->field = estrdup((char *)field);
+    range->lower_term = lower_term ? estrdup(lower_term) : NULL;
+    range->upper_term = upper_term ? estrdup(upper_term) : NULL;
+    range->include_lower = include_lower;
+    range->include_upper = include_upper;
+    return range;
 }
 
 /***************************************************************************
@@ -123,109 +137,112 @@ Range *range_create(const char *field, char *lower_term, char *upper_term,
  *
  ***************************************************************************/
 
-void rfilt_destroy(Filter *self)
+typedef struct RangeFilter
+{
+    Filter super;
+    Range *range;
+} RangeFilter;
+
+#define RF(filt) ((RangeFilter *)(filt))
+
+static void rfilt_destroy_i(Filter *filt)
 {
-  range_destroy(self->data);
-  filt_destroy(self);
+    range_destroy(RF(filt)->range);
+    filt_destroy_i(filt);
 }
 
-char *rfilt_to_s(Filter *self)
+static char *rfilt_to_s(Filter *filt)
 {
-  Range *range = (Range *)self->data;
-  char *rstr = range_to_s(range, "", 1.0);
-  char *rfstr = epstrdup("RangeFilter< %s >", strlen(rstr), rstr);
-  free(rstr);
-  return rfstr;
+    char *rstr = range_to_s(RF(filt)->range, "", 1.0);
+    char *rfstr = strfmt("RangeFilter< %s >", rstr);
+    free(rstr);
+    return rfstr;
 }
 
-BitVector *rfilt_get_bv(Filter *self, IndexReader *ir)
+static BitVector *rfilt_get_bv_i(Filter *filt, IndexReader *ir)
 {
-  BitVector *bv = bv_create_size(ir->max_doc(ir));
-  Range *range = (Range *)self->data;
-  char *field = range->field;
-  char *lower_term = range->lower_term ? range->lower_term : (char *)EMPTY_STRING;
-  char *upper_term = range->upper_term;
-  bool include_upper = range->include_upper;
-
-  Term *term_from = term_create(range->field, lower_term);
-  Term term;
-  TermBuffer *tb;
-  TermEnum* te;
-  TermDocEnum *tde;
-  bool check_lower;
-
-  te = ir->terms_from(ir, term_from);
-  if (te->tb_curr == NULL) {
-    return bv;
-  }
-            
-  check_lower = false;
-  if (!range->include_lower) // make adjustments to set to exclusive
-      check_lower = true;
-        
-  tde = ir->term_docs(ir);
-  tb = te->tb_curr;
-  term.text = tb->text;
-  do {
-    if (tb && strcmp(tb->field, field) == 0) {
-      if (!check_lower || lower_term == EMPTY_STRING ||
-          strcmp(tb->text, lower_term) > 0) {
-        check_lower = false;
-        if (upper_term) {
-          int compare = strcmp(upper_term, tb->text);
-          /* if beyond the upper term, or is exclusive and
-           * this is equal to the upper term, break out */
-          if ((compare < 0) ||
-              (!include_upper && compare==0)) {
-              break;
-          }
-        }
-        /* we have a good term, find the docs */
-        /* text is already pointing to term buffer text */
-        term.field = tb->field;
-        tde->seek(tde, &term);
-        while (tde->next(tde)) {
-          bv_set(bv, tde->doc_num(tde));
-          //printf("Setting %d\n", tde->doc_num(tde));
+    BitVector *bv = bv_new_capa(ir->max_doc(ir));
+    Range *range = RF(filt)->range;
+    FieldInfo *fi = fis_get_field(ir->fis, range->field);
+    /* the field info exists we need to add docs to the bit vector, otherwise
+     * we just return an empty bit vector */
+    if (fi) {
+        const char *lower_term =
+            range->lower_term ? range->lower_term : EMPTY_STRING;
+        const char *upper_term = range->upper_term;
+        const bool include_upper = range->include_upper;
+        const int field_num = fi->number;
+        char *term;
+        TermEnum* te;
+        TermDocEnum *tde;
+        bool check_lower;
+
+        te = ir->terms(ir, field_num);
+        if (te->skip_to(te, lower_term) == NULL) {
+            te->close(te);
+            return bv;
         }
-      }
-    } else {
-      break;
+
+        check_lower = !(range->include_lower || (lower_term == EMPTY_STRING));
+
+        tde = ir->term_docs(ir);
+        term = te->curr_term;
+        do {
+            if (!check_lower
+                || (strcmp(term, lower_term) > 0)) {
+                check_lower = false;
+                if (upper_term) {
+                    int compare = strcmp(upper_term, term);
+                    /* Break if upper term is greater than or equal to upper
+                     * term and include_upper is false or ther term is fully
+                     * greater than upper term. This is optimized so that only
+                     * one check is done except in last check or two */
+                    if ((compare <= 0)
+                        && (!include_upper || (compare < 0))) {
+                        break;
+                    }
+                }
+                /* we have a good term, find the docs */
+                /* text is already pointing to term buffer text */
+                tde->seek_te(tde, te);
+                while (tde->next(tde)) {
+                    bv_set(bv, tde->doc_num(tde));
+                    /* printf("Setting %d\n", tde->doc_num(tde)); */
+                }
+            }
+        } while (te->next(te));
+
+        tde->close(tde);
+        te->close(te);
     }
-  } while (te->next(te));
-          
-  tde->close(tde);
-  te->close(te);
-  term_destroy(term_from);
 
-  return bv;
+    return bv;
 }
 
-uint rfilt_hash(Filter *self)
+static ulong rfilt_hash(Filter *filt)
 {
-  return range_hash((Range *)self->data);
+    return range_hash(RF(filt)->range);
 }
 
-int rfilt_eq(Filter *self, Filter *o)
+static int rfilt_eq(Filter *filt, Filter *o)
 {
-  return range_eq((Range *)self->data, (Range *)o->data);
+    return range_eq(RF(filt)->range, RF(o)->range);
 }
 
-Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
-    bool include_lower, bool include_upper)
+Filter *rfilt_new(const char *field,
+                  const char *lower_term, const char *upper_term,
+                  bool include_lower, bool include_upper)
 {
-  Filter *self;
-  Range *range = range_create(field, lower_term, upper_term,
-      include_lower, include_upper); 
-
-  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;
+    Filter *filt = filt_new(RangeFilter);
+    RF(filt)->range =  range_new(field, lower_term, upper_term,
+                                 include_lower, include_upper); 
+
+    filt->get_bv_i  = &rfilt_get_bv_i;
+    filt->hash      = &rfilt_hash;
+    filt->eq        = &rfilt_eq;
+    filt->to_s      = &rfilt_to_s;
+    filt->destroy_i = &rfilt_destroy_i;
+    return filt;
 }
 
 /*****************************************************************************
@@ -234,61 +251,69 @@ Filter *rfilt_create(const char *field, char *lower_term, char *upper_term,
  *
  *****************************************************************************/
 
-char *rq_to_s(Query *self, char *field)
+#define RQ(query) ((RangeQuery *)(query))
+typedef struct RangeQuery
+{
+    Query f;
+    Range *range;
+} RangeQuery;
+
+static char *rq_to_s(Query *self, const char *field)
 {
-  Range *range = (Range *)self->data;
-  return range_to_s(range, field, self->boost);
+    return range_to_s(RQ(self)->range, field, self->boost);
 }
 
-void rq_destroy(Query *self)
+static void rq_destroy(Query *self)
 {
-  range_destroy(self->data);
-  q_destroy_i(self);
+    range_destroy(RQ(self)->range);
+    q_destroy_i(self);
 }
 
-Query *rq_rewrite(Query *self, IndexReader *ir)
+static 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);
-  return csq_create(filter);
+    Range *r = RQ(self)->range;
+    Filter *filter = rfilt_new(r->field, r->lower_term, r->upper_term,
+                               r->include_lower, r->include_upper);
+    (void)ir;
+    return csq_new_nr(filter);
 }
 
-static uint rq_hash(Query *self)
+static ulong rq_hash(Query *self)
 {
-  return range_hash((Range *)self->data);
+    return range_hash(RQ(self)->range);
 }
 
 static int rq_eq(Query *self, Query *o)
 {
-  return range_eq((Range *)self->data, (Range *)o->data);
+    return range_eq(RQ(self)->range, RQ(o)->range);
 }
 
-Query *rq_create_less(const char *field, char *upper_term, bool include_upper)
+Query *rq_new_less(const char *field, const char *upper_term,
+                   bool include_upper)
 {
-  return rq_create(field, NULL, upper_term, false, include_upper);
+    return rq_new(field, NULL, upper_term, false, include_upper);
 }
 
-Query *rq_create_more(const char *field, char *lower_term, bool include_lower)
+Query *rq_new_more(const char *field, const char *lower_term,
+                   bool include_lower)
 {
-  return rq_create(field, lower_term, NULL, include_lower, false);
+    return rq_new(field, lower_term, NULL, include_lower, false);
 }
 
-Query *rq_create(const char *field, char *lower_term, char *upper_term,
-    bool include_lower, bool include_upper)
+Query *rq_new(const char *field, const char *lower_term,
+              const char *upper_term, bool include_lower, bool include_upper)
 {
-  Query *self = q_create();
-  Range *range = range_create(field, lower_term, upper_term,
-      include_lower, include_upper); 
-
-  self->data = range;
-
-  self->type = RANGE_QUERY;
-  self->rewrite = &rq_rewrite;
-  self->to_s = &rq_to_s;
-  self->hash = &rq_hash;
-  self->eq = &rq_eq;
-  self->destroy_i = &rq_destroy;
-  self->create_weight_i = &q_create_weight_unsup;
-  return self;
+    Query *self     = q_new(RangeQuery);
+
+    RQ(self)->range = range_new(field, lower_term, upper_term,
+                                include_lower, include_upper); 
+
+    self->type              = RANGE_QUERY;
+    self->rewrite           = &rq_rewrite;
+    self->to_s              = &rq_to_s;
+    self->hash              = &rq_hash;
+    self->eq                = &rq_eq;
+    self->destroy_i         = &rq_destroy;
+    self->create_weight_i   = &q_create_weight_unsup;
+    return self;
 }