ferret 0.9.6 → 0.10.0

data/ext/helper.c

@@ -3,9 +3,60 @@
 inline int hlp_string_diff(register const char *const s1,
                            register const char *const s2)
 {
-  register int i = 0;
-  while (s1[i] && (s1[i] == s2[i])) {
-    i++;
-  }
-  return i;
+    register int i = 0;
+    while (s1[i] && (s1[i] == s2[i])) {
+        i++;
+    }
+    return i;
+}
+
+f_i32 float2int(float f)
+{
+    union { f_i32 i; float f; } tmp;
+    tmp.f = f;
+    return POSH_LittleU32(tmp.i);
+}
+
+float int2float(f_i32 i32)
+{
+    union { f_i32 i; float f; } tmp;
+    tmp.i = POSH_LittleU32(i32);
+    return tmp.f;
+}
+
+float byte2float(unsigned char b)
+{
+    if (b == 0) {
+        return 0.0;
+    }
+    else {
+        f_u32 mantissa = b & 0x07;
+        f_u32 exponent = (b >> 3) & 0x1f;
+
+        return int2float((mantissa << 21) | ((exponent + 48) << 24));
+    }
+}
+
+unsigned char float2byte(float f)
+{
+    if (f <= 0.0) {
+        return 0;
+    }
+    else {
+        /* correctly order the bytes for encoding */
+        f_u32 i32 = float2int(f);
+        int mantissa = (i32 & 0xEf0000) >> 21;
+        int exponent = ((i32 >> 24) - 48);
+
+        if (exponent > 0x1f) {
+            exponent = 0x1f;   /* 0x1f = 31 = 0b00011111 */
+            mantissa = 0x07;   /* 0x07 =  7 = 0b00000111 */
+        }
+
+        if (exponent < 0) {
+            exponent = 0;
+            mantissa = 1;
+        }
+        return ((exponent<<3) | mantissa);
+    }
 }

data/ext/helper.h

@@ -1,6 +1,13 @@
 #ifndef FRT_HELPER_H
 #define FRT_HELPER_H
 
+#include "defines.h"
+
 extern inline int hlp_string_diff(register const char *const s1,
                                   register const char *const s2);
+extern f_i32 float2int(float f);
+extern float int2float(f_i32 i32);
+extern float byte2float(unsigned char b);
+extern unsigned char float2byte(float f);
+
 #endif

data/ext/inc/lang.h

@@ -2,60 +2,40 @@
 #define FRT_LANG_H
 
 #include <ruby.h>
-#include "hash.h"
+#include <stdarg.h>
 
-#define FERRET_EXT
+#define frt_malloc xmalloc
+#define frt_calloc(n) xcalloc(n, 1)
+#define frt_realloc xrealloc
 
-#define MAX_ERROR_LEN 2048
+#ifdef FRT_HAS_ISO_VARARGS
+/* C99-compliant compiler */
 
-typedef LONG_LONG llong;
-typedef unsigned LONG_LONG ullong;
+# define FRT_EXIT(...) frt_rb_raise(__FILE__, __LINE__, __func__, __VA_ARGS__)
+extern void frt_rb_raise(const char *file, int line_num, const char *func,
+                         const char *err_type, const char *fmt, ...);
 
-#ifdef WIN32
-# undef close
-# undef rename
-extern void eprintf(VALUE etype, const char *fmt, ...);
+# define V_FRT_EXIT(err_type, fmt, args) \
+    vfrt_rb_raise(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void vfrt_rb_raise(const char *file, int line_num, const char *func,
+                          const char *err_type, const char *fmt, va_list args);
+
+#elif defined(FRT_HAS_GNUC_VARARGS)
+/* gcc has an extension */
+
+# define FRT_EXIT(args...) frt_rb_raise(__FILE__, __LINE__, __func__, ##args)
+extern void frt_rb_raise(const char *file, int line_num, const char *func,
+                         const char *err_type, const char *fmt, ...);
+
+# define V_FRT_EXIT(err_type, fmt, args) \
+    vfrt_rb_raise(__FILE__, __LINE__, __func__, err_type, fmt, args)
+extern void vfrt_rb_raise(const char *file, int line_num, const char *func,
+                          const char *err_type, const char *fmt, va_list args);
 #else
-# define eprintf(...) ft_raise(__FILE__, __LINE__, __VA_ARGS__)
+/* Can't do VARARGS */
+
+extern void FRT_EXIT(const char *err_type, const char *fmt, ...);
+extern void V_FRT_EXIT(const char *err_type, const char *fmt, va_list args);
 #endif
-extern void ft_raise(char *file, int line_num, VALUE etype, const char *fmt, ...);
-extern void weprintf(const char *fmt, ...);
-extern char *progname(void);
-extern void setprogname(const char *str);
-
-extern VALUE cQueryParseException;
-
-#define EXCEPTION_CODE rb_eStandardError
-//#define IO_ERROR rb_eIOError
-//#define ARG_ERROR rb_eArgError
-//#define EOF_ERROR rb_eEOFError
-//#define UNSUPPORTED_ERROR rb_eNotImpError
-//#define STATE_ERROR rb_eException
-//#define PARSE_ERROR cQueryParseException
-//#define MEM_ERROR rb_eNoMemError
-
-typedef void * mutex_t;
-typedef struct HshTable * thread_key_t;
-typedef int thread_once_t;
-#define MUTEX_INITIALIZER NULL
-#define MUTEX_RECURSIVE_INITIALIZER NULL
-#define THREAD_ONCE_INIT 1;
-#define mutex_init(a, b)
-#define mutex_lock(a)
-#define mutex_trylock(a)
-#define mutex_unlock(a)
-#define mutex_destroy(a)
-#define thread_key_create(a, b) frt_thread_key_create(a, b)
-#define thread_key_delete(a) frt_thread_key_delete(a)
-#define thread_setspecific(a, b) frt_thread_setspecific(a, b)
-#define thread_getspecific(a) frt_thread_getspecific(a)
-#define thread_exit(a)
-#define thread_once(a, b) frt_thread_once(a, b)
-
-void frt_thread_once(int *once_control, void (*init_routine) (void));
-void frt_thread_key_create(thread_key_t *key, void (*destr_function) (void *));
-void frt_thread_key_delete(thread_key_t key);
-void frt_thread_setspecific(thread_key_t key, const void *pointer);
-void *frt_thread_getspecific(thread_key_t key);
 
 #endif

data/ext/inc/threading.h

@@ -0,0 +1,31 @@
+#ifndef FRT_THREADING_H
+#define FRT_THREADING_H
+
+#include "hash.h"
+#define UNTHREADED 1
+
+typedef void * mutex_t;
+typedef struct HashTable *thread_key_t;
+typedef int thread_once_t;
+#define MUTEX_INITIALIZER NULL
+#define MUTEX_RECURSIVE_INITIALIZER NULL
+#define THREAD_ONCE_INIT 1;
+#define mutex_init(a, b)
+#define mutex_lock(a)
+#define mutex_trylock(a)
+#define mutex_unlock(a)
+#define mutex_destroy(a)
+#define thread_key_create(a, b) frt_thread_key_create(a, b)
+#define thread_key_delete(a) frt_thread_key_delete(a)
+#define thread_setspecific(a, b) frt_thread_setspecific(a, b)
+#define thread_getspecific(a) frt_thread_getspecific(a)
+#define thread_exit(a)
+#define thread_once(a, b) frt_thread_once(a, b)
+
+void frt_thread_once(int *once_control, void (*init_routine)(void));
+void frt_thread_key_create(thread_key_t *key, void (*destr_function)(void *));
+void frt_thread_key_delete(thread_key_t key);
+void frt_thread_setspecific(thread_key_t key, const void *pointer);
+void *frt_thread_getspecific(thread_key_t key);
+
+#endif

data/ext/ind.c

@@ -1,4 +1,5 @@
-#include "search.h"
+#include "ind.h"
+#include "array.h"
 #include <string.h>
 
 
@@ -7,402 +8,411 @@ static char * const NON_UNIQUE_KEY_ERROR_MSG = "Tried to use a key that was not
 static const char *ID_STRING = "id";
 
 #define INDEX_CLOSE_READER(self) do {\
-  if (self->sea) {\
-    sea_close(self->sea);\
-    self->sea = NULL;\
-    self->ir = NULL;\
-  } else if (self->ir) {\
-    ir_close(self->ir);\
-    self->ir = NULL;\
-  }\
+    if (self->sea) {\
+        searcher_close(self->sea);\
+        self->sea = NULL;\
+        self->ir = NULL;\
+    } else if (self->ir) {\
+        ir_close(self->ir);\
+        self->ir = NULL;\
+    }\
 } while (0)
 
 #define AUTOFLUSH_IR if (self->auto_flush) ir_commit(self->ir);\
-  else self->has_writes = true
+    else self->has_writes = true
 
 #define AUTOFLUSH_IW \
-  if (self->auto_flush) {\
-    iw_close(self->iw);\
-    self->iw = NULL;\
-  } else self->has_writes = true
+    if (self->auto_flush) {\
+        iw_close(self->iw);\
+        self->iw = NULL;\
+    } else self->has_writes = true
 
 void index_auto_flush_ir(Index *self)
 {
-  AUTOFLUSH_IR;
+    AUTOFLUSH_IR;
 }
 
 void index_auto_flush_iw(Index *self)
 {
-  AUTOFLUSH_IW;
+    AUTOFLUSH_IW;
 }
 
-Index *index_create(Store *store, Analyzer *analyzer, HashSet *def_fields,
-    bool create)
+Index *index_new(Store *store, Analyzer *analyzer, HashSet *def_fields,
+                 bool create)
 {
-  HashSet *all_fields = hs_str_create(&free);
-  Index *self = ALLOC(Index);
-  ZEROSET(self, Index, 1);
-  mutex_init(&self->mutex, NULL);
-  self->has_writes = false;
-  if (store) {
-    self->store = store;
-    ref(store);
-  } else {
-    self->store = open_ram_store();
-    create = true;
-  }
-  if (analyzer) {
-    self->analyzer = analyzer;
-    ref(analyzer);
-  } else {
-    self->analyzer = mb_standard_analyzer_create(true);
-  }
-  self->use_compound_file = true;
-
-  if (create) {
-    ref(self->analyzer);
-    self->iw = iw_open(self->store, self->analyzer, create);
-    iw_close(self->iw);
-    self->iw = NULL;
-  }
-
-  /* options */
-  self->key = NULL;
-  self->id_field = (char *)ID_STRING;
-  self->def_field = (char *)ID_STRING;
-  self->auto_flush = false;
-  self->check_latest = true;
-
-  ref(self->analyzer);
-  self->qp = qp_create(all_fields, def_fields, self->analyzer);
-  /* Index is a convenience class so set qp convenience options */
-  self->qp->allow_any_fields = true;
-  self->qp->clean_str = true;
-  self->qp->handle_parse_errors = true;
-
-  return self;
+    HashSet *all_fields = hs_new_str(&free);
+    Index *self = ALLOC_AND_ZERO(Index);
+    self->config = default_config;
+    mutex_init(&self->mutex, NULL);
+    self->has_writes = false;
+    if (store) {
+        self->store = store;
+        REF(store);
+    } else {
+        self->store = open_ram_store();
+        create = true;
+    }
+    if (analyzer) {
+        self->analyzer = analyzer;
+        REF(analyzer);
+    } else {
+        self->analyzer = mb_standard_analyzer_new(true);
+    }
+
+    if (create) {
+        FieldInfos *fis = fis_new(STORE_YES, INDEX_YES,
+                                  TERM_VECTOR_WITH_POSITIONS_OFFSETS);
+        index_create(store, fis);
+        fis_deref(fis);
+    }
+
+    /* options */
+    self->key = NULL;
+    self->id_field = estrdup(ID_STRING);
+    self->def_field = estrdup(ID_STRING);
+    self->auto_flush = false;
+    self->check_latest = true;
+
+    REF(self->analyzer);
+    self->qp = qp_new(all_fields, def_fields, self->analyzer);
+    /* Index is a convenience class so set qp convenience options */
+    self->qp->allow_any_fields = true;
+    self->qp->clean_str = true;
+    self->qp->handle_parse_errors = true;
+
+    return self;
 }
 
 void index_destroy(Index *self)
 {
-  mutex_destroy(&self->mutex);
-  INDEX_CLOSE_READER(self);
-  if (self->iw) iw_close(self->iw);
-  store_deref(self->store);
-  a_deref(self->analyzer);
-  if (self->qp) qp_destroy(self->qp);
-  if (self->id_field != ((char *)ID_STRING)) free(self->id_field);
-  if (self->def_field != ((char *)ID_STRING)) free(self->def_field);
-  if (self->key) hs_destroy_all(self->key);
-  free(self);
+    mutex_destroy(&self->mutex);
+    INDEX_CLOSE_READER(self);
+    if (self->iw) iw_close(self->iw);
+    store_deref(self->store);
+    a_deref(self->analyzer);
+    if (self->qp) qp_destroy(self->qp);
+    if (self->key) hs_destroy(self->key);
+    free(self->id_field);
+    free(self->def_field);
+    free(self);
 }
 
 void index_flush(Index *self)
 {
-  if (self->ir) {
-    ir_commit(self->ir);
-  } else if (self->iw) {
-    iw_close(self->iw);
-    self->iw = NULL;
-  }
-  self->has_writes = false;
+    if (self->ir) {
+        ir_commit(self->ir);
+    } else if (self->iw) {
+        iw_close(self->iw);
+        self->iw = NULL;
+    }
+    self->has_writes = false;
 }
 
 inline void ensure_writer_open(Index *self)
 {
-  if (!self->iw) {
-    INDEX_CLOSE_READER(self);
-
-    /* make sure the analzyer isn't deleted by the IndexWriter */
-    ref(self->analyzer);
-    self->iw = iw_open(self->store, self->analyzer, false);
-    self->iw->use_compound_file = self->use_compound_file;
-  } else if (self->analyzer != self->iw->analyzer) {
-    a_deref(self->iw->analyzer);
-    ref(self->analyzer);
-    self->iw->analyzer = self->analyzer; /* in case it has changed */
-  }
+    if (!self->iw) {
+        INDEX_CLOSE_READER(self);
+
+        /* make sure the analzyer isn't deleted by the IndexWriter */
+        REF(self->analyzer);
+        self->iw = iw_open(self->store, self->analyzer, false);
+        self->iw->config.use_compound_file = self->config.use_compound_file;
+    } else if (self->analyzer != self->iw->analyzer) {
+        a_deref(self->iw->analyzer);
+        REF(self->analyzer);
+        self->iw->analyzer = self->analyzer; /* in case it has changed */
+    }
 }
 
 inline void ensure_reader_open(Index *self)
 {
-  if (self->ir) {
-    if (self->check_latest && !ir_is_latest(self->ir)) {
-      INDEX_CLOSE_READER(self);
-      self->ir = ir_open(self->store);
-    }
-  } else {
-    if (self->iw) {
-      iw_close(self->iw);
-      self->iw = NULL;
+    if (self->ir) {
+        if (self->check_latest && !ir_is_latest(self->ir)) {
+            INDEX_CLOSE_READER(self);
+            self->ir = ir_open(self->store);
+        }
+    } else {
+        if (self->iw) {
+            iw_close(self->iw);
+            self->iw = NULL;
+        }
+        self->ir = ir_open(self->store);
     }
-    self->ir = ir_open(self->store);
-  }
 }
 
 inline void ensure_searcher_open(Index *self)
 {
-  ensure_reader_open(self);
-  if (!self->sea) {
-    self->sea = sea_create(self->ir);
-  }
+    ensure_reader_open(self);
+    if (!self->sea) {
+        self->sea = isea_new(self->ir);
+    }
 }
 
 int index_size(Index *self)
 {
-  int size;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  size = self->ir->num_docs(self->ir);
-  mutex_unlock(&self->store->ext_mutex);
-  return size;
+    int size;
+    mutex_lock(&self->mutex);
+    ensure_reader_open(self);
+    size = self->ir->num_docs(self->ir);
+    mutex_unlock(&self->mutex);
+    return size;
 }
 
 void index_optimize(Index *self)
 {
-  mutex_lock(&self->store->ext_mutex);
-  ensure_writer_open(self);
-  iw_optimize(self->iw);
-  AUTOFLUSH_IW;
-  mutex_unlock(&self->store->ext_mutex);
+    mutex_lock(&self->mutex);
+    ensure_writer_open(self);
+    iw_optimize(self->iw);
+    AUTOFLUSH_IW;
+    mutex_unlock(&self->mutex);
 }
 
 bool index_has_del(Index *self)
 {
-  bool has_del;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  has_del = self->ir->has_deletions(self->ir);
-  mutex_unlock(&self->store->ext_mutex);
-  return has_del;
+    bool has_del;
+    mutex_lock(&self->mutex);
+    ensure_reader_open(self);
+    has_del = self->ir->has_deletions(self->ir);
+    mutex_unlock(&self->mutex);
+    return has_del;
 }
 
 bool index_is_deleted(Index *self, int doc_num)
 {
-  bool is_del;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  is_del = self->ir->is_deleted(self->ir, doc_num);
-  mutex_unlock(&self->store->ext_mutex);
-  return is_del;
+    bool is_del;
+    mutex_lock(&self->mutex);
+    ensure_reader_open(self);
+    is_del = self->ir->is_deleted(self->ir, doc_num);
+    mutex_unlock(&self->mutex);
+    return is_del;
 }
 
-static void inline index_add_doc_i(Index *self, Document *doc)
+static inline void index_add_doc_i(Index *self, Document *doc)
 {
-  /* If there is a key specified delete the document with the same key */
-  if (self->key) {
-    int i;
-    char *field;
-    DocField *df;
-    Query *q = bq_create(false);
-    TopDocs *td;
-    ensure_searcher_open(self);
-    for (i = 0; i < self->key->size; i++) {
-      field = self->key->elems[i];
-      df = doc_get_field(doc, field);
-      if (!df) continue;
-      bq_add_query(q, tq_create(term_create(field, df->data)), BC_MUST);
-    }
-    td = sea_search(self->sea, q, 0, 1, NULL, NULL);
-    if (td->total_hits > 1) {
-      td_destroy(td);
-      RAISE(ARG_ERROR, NON_UNIQUE_KEY_ERROR_MSG);
-    } else if (td->total_hits == 1) {
-      ir_delete_doc(self->ir, td->hits[0]->doc);
+    /* If there is a key specified delete the document with the same key */
+    if (self->key) {
+        int i;
+        char *field;
+        DocField *df;
+        if (self->key->size == 1) {
+            ensure_writer_open(self);
+            field = self->key->elems[0];
+            df = doc_get_field(doc, field);
+            if (df) {
+                iw_delete_term(self->iw, field, df->data[0]);
+            }
+        } else {
+            Query *q = bq_new(false);
+            TopDocs *td;
+            ensure_searcher_open(self);
+            for (i = 0; i < self->key->size; i++) {
+                field = self->key->elems[i];
+                df = doc_get_field(doc, field);
+                if (!df) continue;
+                bq_add_query(q, tq_new(field, df->data[0]), BC_MUST);
+            }
+            td = searcher_search(self->sea, q, 0, 1, NULL, NULL, NULL);
+            if (td->total_hits > 1) {
+                td_destroy(td);
+                RAISE(ARG_ERROR, NON_UNIQUE_KEY_ERROR_MSG);
+            } else if (td->total_hits == 1) {
+                ir_delete_doc(self->ir, td->hits[0]->doc);
+            }
+            q_deref(q);
+            td_destroy(td);
+        }
     }
-    q_deref(q);
-    td_destroy(td);
-  }
-  ensure_writer_open(self);
-  iw_add_doc(self->iw, doc);
-  AUTOFLUSH_IW;
+    ensure_writer_open(self);
+    iw_add_doc(self->iw, doc);
+    AUTOFLUSH_IW;
 }
 
 void index_add_doc_a(Index *self, Document *doc, Analyzer *analyzer)
 {
-  Analyzer *tmp_analyzer;
-  mutex_lock(&self->store->ext_mutex);
-  if (analyzer != self->analyzer) {
-    ref(analyzer);
-    tmp_analyzer = self->analyzer;
-    self->analyzer = analyzer;
-    index_add_doc_i(self, doc);
-    self->analyzer = tmp_analyzer;
-    a_deref(analyzer);
-  } else {
-    index_add_doc_i(self, doc);
-  }
-  mutex_unlock(&self->store->ext_mutex);
+    Analyzer *tmp_analyzer;
+    mutex_lock(&self->mutex);
+    if (analyzer != self->analyzer) {
+        REF(analyzer);
+        tmp_analyzer = self->analyzer;
+        self->analyzer = analyzer;
+        index_add_doc_i(self, doc);
+        self->analyzer = tmp_analyzer;
+        a_deref(analyzer);
+    } else {
+        index_add_doc_i(self, doc);
+    }
+    mutex_unlock(&self->mutex);
 }
 
 void index_add_doc(Index *self, Document *doc)
 {
-  mutex_lock(&self->store->ext_mutex);
-  index_add_doc_i(self, doc);
-  mutex_unlock(&self->store->ext_mutex);
+    mutex_lock(&self->mutex);
+    index_add_doc_i(self, doc);
+    mutex_unlock(&self->mutex);
 }
 
 void index_add_string(Index *self, char *str, Analyzer *analyzer)
 {
-  Document *doc = doc_create();
-  doc_add_field(doc, df_create(self->def_field, estrdup(str),
-        DF_STORE_YES, DF_INDEX_TOKENIZED, DF_TERM_VECTOR_NO));
-  if (analyzer) index_add_doc_a(self, doc, analyzer);
-  else index_add_doc(self, doc);
-  doc_destroy(doc);
+    Document *doc = doc_new();
+    doc_add_field(doc, df_add_data(df_new(self->def_field), estrdup(str)));
+    if (analyzer) index_add_doc_a(self, doc, analyzer);
+    else index_add_doc(self, doc);
+    doc_destroy(doc);
 }
 
-void index_add_array(Index *self, Array *ary, Analyzer *analyzer)
+void index_add_array(Index *self, char **fields, Analyzer *analyzer)
 {
-  int i;
-  Document *doc = doc_create();
-  for (i = 0; i < ary->size; i++) {
-    doc_add_field(doc, df_create(self->def_field, estrdup(ary->elems[i]),
-        DF_STORE_YES, DF_INDEX_TOKENIZED, DF_TERM_VECTOR_NO));
-  }
-  if (analyzer) index_add_doc_a(self, doc, analyzer);
-  else index_add_doc(self, doc);
-  doc_destroy(doc);
+    int i;
+    Document *doc = doc_new();
+    for (i = 0; i < ary_size(fields); i++) {
+        doc_add_field(doc, df_add_data(df_new(self->def_field),
+                                       estrdup(fields[i])));
+    }
+    if (analyzer) index_add_doc_a(self, doc, analyzer);
+    else index_add_doc(self, doc);
+    doc_destroy(doc);
 }
 
 Query *index_get_query(Index *self, char *qstr)
 {
-  int i;
-  HashSet *all_fields;
-  ensure_searcher_open(self);
-  all_fields = self->ir->get_field_names(self->ir, IR_ALL);
-  for (i = 0; i < all_fields->size; i++)
-    hs_add(self->qp->all_fields, estrdup(all_fields->elems[i]));
-  hs_destroy(all_fields);
-  return qp_parse(self->qp, qstr);
+    int i;
+    FieldInfos *fis;
+    ensure_searcher_open(self);
+    fis = self->ir->fis;
+    for (i = fis->size - 1; i >= 0; i--) {
+        char *field = fis->fields[i]->name;
+        hs_add(self->qp->all_fields, estrdup(field));
+    }
+    return qp_parse(self->qp, qstr);
 }
 
 TopDocs *index_search_str(Index *self, char *qstr, int first_doc,
-    int num_docs, Filter *filter, Sort *sort)
+                          int num_docs, Filter *filter, Sort *sort,
+                          filter_ft filter_func)
 {
-  Query *query;
-  TopDocs *td;
-  query = index_get_query(self, qstr); /* will ensure_searcher is open */
-  //printf(">> %s <<\n", query->to_s(query, ""));
-  td = sea_search(self->sea, query, first_doc, num_docs, filter, sort);
-  q_deref(query);
-  return td;
+    Query *query;
+    TopDocs *td;
+    query = index_get_query(self, qstr); /* will ensure_searcher is open */
+    td = searcher_search(self->sea, query, first_doc, num_docs,
+                         filter, sort, filter_func);
+    q_deref(query);
+    return td;
 }
 
 Document *index_get_doc(Index *self, int doc_num)
 {
-  Document *doc;
-  ensure_reader_open(self);
-  doc = self->ir->get_doc(self->ir, doc_num);
-  return doc;
+    Document *doc;
+    ensure_reader_open(self);
+    doc = self->ir->get_doc(self->ir, doc_num);
+    return doc;
 }
 
 Document *index_get_doc_ts(Index *self, int doc_num)
 {
-  Document *doc;
-  mutex_lock(&self->store->ext_mutex);
-  doc = index_get_doc(self, doc_num);
-  mutex_unlock(&self->store->ext_mutex);
-  return doc;
+    Document *doc;
+    mutex_lock(&self->mutex);
+    doc = index_get_doc(self, doc_num);
+    mutex_unlock(&self->mutex);
+    return doc;
 }
 
-int index_term_id(Index *self, Term *term)
+int index_term_id(Index *self, const char *field, const char *term)
 {
-  TermDocEnum *tde;
-  int doc_num = -1;
-  ensure_reader_open(self);
-  tde = ir_term_docs_for(self->ir, term);
-  if (tde->next(tde)) {
-    doc_num = tde->doc_num(tde);
-  }
-  tde->close(tde);
-  return doc_num;
+    TermDocEnum *tde;
+    int doc_num = -1;
+    ensure_reader_open(self);
+    tde = ir_term_docs_for(self->ir, field, term);
+    if (tde->next(tde)) {
+        doc_num = tde->doc_num(tde);
+    }
+    tde->close(tde);
+    return doc_num;
 }
 
-Document *index_get_doc_term(Index *self, Term *term)
+Document *index_get_doc_term(Index *self, const char *field,
+                             const char *term)
 {
-  Document *doc = NULL;
-  TermDocEnum *tde;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  tde = ir_term_docs_for(self->ir, term);
-  if (tde->next(tde)) {
-    doc = index_get_doc(self, tde->doc_num(tde));
-  }
-  tde->close(tde);
-  mutex_unlock(&self->store->ext_mutex);
-  return doc;
+    Document *doc = NULL;
+    TermDocEnum *tde;
+    mutex_lock(&self->mutex);
+    ensure_reader_open(self);
+    tde = ir_term_docs_for(self->ir, field, term);
+    if (tde->next(tde)) {
+        doc = index_get_doc(self, tde->doc_num(tde));
+    }
+    tde->close(tde);
+    mutex_unlock(&self->mutex);
+    return doc;
 }
 
-Document *index_get_doc_id(Index *self, char *id)
+Document *index_get_doc_id(Index *self, const char *id)
 {
-  Term t;
-  t.field = self->id_field;
-  t.text = id;
-  return index_get_doc_term(self, &t);
+    return index_get_doc_term(self, self->id_field, id);
 }
 
 void index_delete(Index *self, int doc_num)
 {
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  ir_delete_doc(self->ir, doc_num);
-  AUTOFLUSH_IR;
-  mutex_unlock(&self->store->ext_mutex);
+    mutex_lock(&self->mutex);
+    ensure_reader_open(self);
+    ir_delete_doc(self->ir, doc_num);
+    AUTOFLUSH_IR;
+    mutex_unlock(&self->mutex);
 }
 
-void index_delete_term(Index *self, Term *term)
+void index_delete_term(Index *self, const char *field, const char *term)
 {
-  TermDocEnum *tde;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_reader_open(self);
-  tde = ir_term_docs_for(self->ir, term);
-  TRY
-    while (tde->next(tde)) {
-      ir_delete_doc(self->ir, tde->doc_num(tde));
-      AUTOFLUSH_IR;
+    TermDocEnum *tde;
+    mutex_lock(&self->mutex);
+    if (self->ir) {
+        tde = ir_term_docs_for(self->ir, field, term);
+        TRY
+            while (tde->next(tde)) {
+                ir_delete_doc(self->ir, tde->doc_num(tde));
+                AUTOFLUSH_IR;
+            }
+        XFINALLY
+            tde->close(tde);
+        XENDTRY
+    } else {
+        ensure_writer_open(self);
+        iw_delete_term(self->iw, field, term);
     }
-  XFINALLY
-    tde->close(tde);
-  XENDTRY
-  mutex_unlock(&self->store->ext_mutex);
+    mutex_unlock(&self->mutex);
 }
 
-void index_delete_id(Index *self, char *id)
+void index_delete_id(Index *self, const char *id)
 {
-  Term t;
-  t.field = self->id_field;
-  t.text = id;
-  index_delete_term(self, &t);
+    index_delete_term(self, self->id_field, id);
 }
 
 static void index_qdel_i(Searcher *sea, int doc_num, float score, void *arg)
 {
-  ir_delete_doc(sea->ir, doc_num);
+    (void)score; (void)arg;
+    ir_delete_doc(((IndexSearcher *)sea)->ir, doc_num);
 }
 
-void index_delete_query(Index *self, Query *q, Filter *f)
+void index_delete_query(Index *self, Query *q, Filter *f, filter_ft ff)
 {
-  mutex_lock(&self->store->ext_mutex);
-  ensure_searcher_open(self);
-  sea_search_each(self->sea, q, f, &index_qdel_i, NULL);
-  AUTOFLUSH_IR;
-  mutex_unlock(&self->store->ext_mutex);
+    mutex_lock(&self->mutex);
+    ensure_searcher_open(self);
+    searcher_search_each(self->sea, q, f, ff, &index_qdel_i, NULL);
+    AUTOFLUSH_IR;
+    mutex_unlock(&self->mutex);
 }
 
-void index_delete_query_str(Index *self, char *qstr, Filter *f)
+void index_delete_query_str(Index *self, char *qstr, Filter *f, filter_ft ff)
 {
-  Query *q = index_get_query(self, qstr);
-  index_delete_query(self, q, f);
-  q_deref(q);
+    Query *q = index_get_query(self, qstr);
+    index_delete_query(self, q, f, ff);
+    q_deref(q);
 }
 
 Explanation *index_explain(Index *self, Query *q, int doc_num)
 {
-  Explanation *expl;
-  mutex_lock(&self->store->ext_mutex);
-  ensure_searcher_open(self);
-  expl = sea_explain(self->sea, q, doc_num);
-  mutex_unlock(&self->store->ext_mutex);
-  return expl;
+    Explanation *expl;
+    mutex_lock(&self->mutex);
+    ensure_searcher_open(self);
+    expl = searcher_explain(self->sea, q, doc_num);
+    mutex_unlock(&self->mutex);
+    return expl;
 }