isomorfeus-ferret 0.12.0

data/ext/isomorfeus_ferret_ext/frt_hashset.h

@@ -0,0 +1,206 @@
+#ifndef FRT_HASHSET_H
+#define FRT_HASHSET_H
+
+#include "frt_hash.h"
+#include "frt_global.h"
+
+typedef struct FrtHashSetEntry {
+    void *elem;
+    struct FrtHashSetEntry *next;
+    struct FrtHashSetEntry *prev;
+} FrtHashSetEntry;
+
+typedef struct FrtHashSet
+{
+    /* the number of elements in the instance */
+    int size;
+
+    /* the first element in the list of elements in the FrtHashSet. The elements
+     * will be listed in the order they were added and can be iterated over by
+     * following the ->next pointer */
+    FrtHashSetEntry *first;
+
+    /* the last element in the list of elements in the FrtHashSet. This is used
+     * internally to add elements to the list. */
+    FrtHashSetEntry *last;
+
+    /* Hash used internally */
+    FrtHash *ht;
+
+    /* Internal: Frees elements added to the FrtHashSet. Should never be NULL */
+    frt_free_ft free_elem_i;
+} FrtHashSet;
+
+/**
+ * Create a new FrtHashSet. The function will allocate a FrtHashSet Struct
+ * setting the functions used to hash the objects it will contain and the eq
+ * function. This should be used for non-string types.
+ *
+ * @param hash function to hash objects added to the FrtHashSet
+ * @param eq function to determine whether two items are equal
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new(frt_hash_ft hash_func,
+                                 frt_eq_ft eq_func,
+                                 frt_free_ft free_func);
+
+/**
+ * Create a new FrtHashSet specifically for strings. This will create a
+ * FrtHashSet as if you used frt_hs_new with the standard string hash and eq
+ * functions.
+ *
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new_str(frt_free_ft free_func);
+
+/**
+ * Create a new FrtHashSet specifically for pointers. Note that the only way
+ * two pointers will be considered equal is if they have the same address. So
+ * you can add the string "key" twice if it is stored at two different
+ * addresses.
+ *
+ * @param free_elem function used to free elements as added to the FrtHashSet
+ *   when the FrtHashSet if destroyed or duplicate elements are added to the Set
+ * @return a newly allocated FrtHashSet structure
+ */
+extern FrtHashSet *frt_hs_new_ptr(frt_free_ft free_func);
+
+/**
+ * Free the memory allocated by the FrtHashSet, but don't free the elements added
+ * to the FrtHashSet. If you'd like to free everything in the FrtHashSet you should
+ * use frt_hs_destroy
+ *
+ * @param hs the FrtHashSet to free
+ */
+extern void frt_hs_free(FrtHashSet *self);
+
+/**
+ * Destroy the FrtHashSet including all elements added to the FrtHashSet. If you'd
+ * like to free the memory allocated to the FrtHashSet without touching the
+ * elements in the FrtHashSet then use frt_hs_free
+ *
+ * @param hs the FrtHashSet to destroy
+ */
+extern void frt_hs_destroy(FrtHashSet *self);
+
+/**
+ * WARNING: this function may destroy some elements if you add them to a
+ * FrtHashSet were equivalent elements already exist, depending on how free_elem
+ * was set.
+ *
+ * Add the element to the FrtHashSet whether or not it was already in the
+ * FrtHashSet.
+ *
+ * When a element is added to the Hash where it already exists, free_elem
+ * is called on it, ie the element you tried to add might get destroyed.
+ *
+ * @param hs the FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
+ * @return one of three values;
+ *   <pre>
+ *     FRT_HASH_KEY_DOES_NOT_EXIST  the element was not already in the FrtHashSet.
+ *                                  This value is equal to 0 or false
+ *     FRT_HASH_KEY_SAME            the element was identical (same memory
+ *                                  pointer) to an existing element so no freeing
+ *                                  was done
+ *     FRT_HASH_KEY_EQUAL           the element was equal to an element already in
+ *                                  the FrtHashSet so the new_elem was freed if
+ *                                  free_elem was set
+ *   </pre>
+ */
+extern FrtHashKeyStatus frt_hs_add(FrtHashSet *self, void *elem);
+
+/**
+ * Add element to the FrtHashSet. If the element already existed in the FrtHashSet
+ * and the new element was equal but not the same (same pointer/memory) then
+ * don't add the element and return false, otherwise return true.
+ *
+ * @param hs the FrtHashSet to add the element to
+ * @param elem the element to add to the FrtHashSet
+ * @return true if the element was successfully added or false otherwise
+ */
+extern int frt_hs_add_safe(FrtHashSet *self, void *elem);
+
+/**
+ * Delete the element from the FrtHashSet. Returns true if the item was
+ * successfully deleted or false if the element never existed.
+ *
+ * @param hs the FrtHashSet to delete from
+ * @param elem the element to delete
+ * @return true if the element was deleted or false if the element never
+ *   existed
+ */
+extern int frt_hs_del(FrtHashSet *self, const void *elem);
+
+/**
+ * Remove an item from the FrtHashSet without actually freeing the item. This
+ * function should return the item itself so that it can be freed later if
+ * necessary.
+ *
+ * @param hs the FrtHashSet to remove the element from.
+ * @param elem the element to remove
+ * @param the element that was removed or NULL otherwise
+ */
+extern void *frt_hs_rem(FrtHashSet *self, const void *elem);
+
+/**
+ * Check if the element exists and return the appropriate value described
+ * bellow.
+ *
+ * @param hs the FrtHashSet to check in
+ * @param elem the element to check for
+ * @return one of the following values
+ * <pre>
+ *     FRT_HASH_KEY_DOES_NOT_EXIST  the element was not already in the FrtHashSet.
+ *                                  This value is equal to 0 or false
+ *     FRT_HASH_KEY_SAME            the element was identical (same memory
+ *                                  pointer) to an existing element so no freeing
+ *                                  was done
+ *     FRT_HASH_KEY_EQUAL           the element was equal to an element already in
+ *                                  the FrtHashSet so the new_elem was freed if
+ *                                  free_elem was set
+ *   </pre>
+ */
+extern FrtHashKeyStatus frt_hs_exists(FrtHashSet *self, const void *elem);
+
+/**
+ * Merge two HashSets. When a merge is done the merger (self) Hash is
+ * returned and the mergee is destroyed. All elements from mergee that were
+ * not found in merger (self) will be added to self, otherwise they will be
+ * destroyed.
+ *
+ * @param self the FrtHashSet to merge into
+ * @param other HastSet to be merged into self
+ * @return the merged FrtHashSet
+ */
+extern FrtHashSet *frt_hs_merge(FrtHashSet *self, FrtHashSet *other);
+
+/**
+ * Return the original version of +elem+. So if you allocate two elements
+ * which are equal and add the first to the FrtHashSet, calling this function
+ * with the second element will return the first element from the FrtHashSet.
+ */
+extern void *frt_hs_orig(FrtHashSet *self, const void *elem);
+
+/**
+ * Clear all elements from the FrtHashSet. If free_elem was set then use it to
+ * free all elements as they are cleared. After the method is called, the
+ * HashSets size will be 0.
+ *
+ * @param self the FrtHashSet to clear
+ */
+extern void frt_hs_clear(FrtHashSet *self);
+
+/* TODO: finish implementing these functions FrtHashSet
+int hs_osf(FrtHashSet *hs, void *elem);
+FrtHashSet hs_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_excl_or(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_and(FrtHashSet *hs1, FrtHashSet *h2);
+FrtHashSet hs_mask(FrtHashSet *hs1, FrtHashSet *h2);
+*/
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_helper.c

@@ -0,0 +1,62 @@
+#include "frt_helper.h"
+
+int frt_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;
+}
+
+frt_i32 frt_float2int(float f)
+{
+    union { frt_i32 i; float f; } tmp;
+    tmp.f = f;
+    return tmp.i;
+}
+
+float frt_int2float(frt_i32 v)
+{
+    union { frt_i32 i; float f; } tmp;
+    tmp.i = v;
+    return tmp.f;
+}
+
+float frt_byte2float(unsigned char b)
+{
+    if (b == 0) {
+        return 0.0;
+    }
+    else {
+        frt_u32 mantissa = b & 0x07;
+        frt_u32 exponent = (b >> 3) & 0x1f;
+
+        return frt_int2float((mantissa << 21) | ((exponent + 48) << 24));
+    }
+}
+
+unsigned char frt_float2byte(float f)
+{
+    if (f <= 0.0) {
+        return 0;
+    }
+    else {
+        /* correctly order the bytes for encoding */
+        frt_u32 i = frt_float2int(f);
+        int mantissa = (i & 0xEf0000) >> 21;
+        int exponent = ((i >> 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/isomorfeus_ferret_ext/frt_helper.h

@@ -0,0 +1,13 @@
+#ifndef FRT_HELPER_H
+#define FRT_HELPER_H
+
+#include "frt_config.h"
+
+extern int frt_hlp_string_diff(register const char *const s1,
+                               register const char *const s2);
+extern frt_i32 frt_float2int(float f);
+extern float frt_int2float(frt_i32 i32);
+extern float frt_byte2float(unsigned char b);
+extern unsigned char frt_float2byte(float f);
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_ind.c

@@ -0,0 +1,353 @@
+#include "frt_ind.h"
+#include "frt_array.h"
+#include <string.h>
+
+static const char *NON_UNIQUE_KEY_ERROR_MSG =
+    "Tried to use a key that was not unique";
+
+#define INDEX_CLOSE_READER(self) do { \
+    if (self->sea) {                  \
+        frt_searcher_close(self->sea);    \
+        self->sea = NULL;             \
+        self->ir = NULL;              \
+    } else if (self->ir) {            \
+        frt_ir_close(self->ir);           \
+        self->ir = NULL;              \
+    }                                 \
+} while (0)
+
+#define AUTOFLUSH_IR(self) do {                 \
+     if (self->auto_flush) frt_ir_commit(self->ir); \
+    else self->has_writes = true;               \
+} while(0)
+
+#define AUTOFLUSH_IW(self) do {  \
+    if (self->auto_flush) {      \
+        frt_iw_close(self->iw);      \
+        self->iw = NULL;         \
+    } else {                     \
+        self->has_writes = true; \
+    }                            \
+} while (0)
+
+FrtIndex *frt_index_new(FrtStore *store, FrtAnalyzer *analyzer, FrtHashSet *def_fields,
+                 bool create)
+{
+    FrtIndex *self = FRT_ALLOC_AND_ZERO(FrtIndex);
+    FrtHashSetEntry *hse;
+    /* FIXME: need to add these to the query parser */
+    self->config = frt_default_config;
+    frt_mutex_init(&self->mutex, NULL);
+    self->has_writes = false;
+    if (store) {
+        FRT_REF(store);
+        self->store = store;
+    } else {
+        self->store = frt_open_ram_store();
+        create = true;
+    }
+    if (analyzer) {
+        self->analyzer = analyzer;
+        FRT_REF(analyzer);
+    } else {
+        self->analyzer = frt_mb_standard_analyzer_new(true);
+    }
+
+    if (create) {
+        FrtFieldInfos *fis = frt_fis_new(FRT_STORE_YES, FRT_INDEX_YES, FRT_TERM_VECTOR_WITH_POSITIONS_OFFSETS);
+        frt_index_create(self->store, fis);
+        frt_fis_deref(fis);
+    }
+
+    /* options */
+    self->key = NULL;
+    self->id_field = rb_intern("id");
+    self->def_field = rb_intern("id");
+    self->auto_flush = false;
+    self->check_latest = true;
+
+    FRT_REF(self->analyzer);
+    self->qp = frt_qp_new(self->analyzer);
+    for (hse = def_fields->first; hse; hse = hse->next) {
+        frt_qp_add_field(self->qp, (FrtSymbol)hse->elem, true, true);
+    }
+    /* 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 frt_index_destroy(FrtIndex *self)
+{
+    frt_mutex_destroy(&self->mutex);
+    INDEX_CLOSE_READER(self);
+    if (self->iw) frt_iw_close(self->iw);
+    frt_store_deref(self->store);
+    frt_a_deref(self->analyzer);
+    if (self->qp) frt_qp_destroy(self->qp);
+    if (self->key) frt_hs_destroy(self->key);
+    free(self);
+}
+
+
+void frt_ensure_writer_open(FrtIndex *self)
+{
+    if (!self->iw) {
+        INDEX_CLOSE_READER(self);
+
+        /* make sure the analzyer isn't deleted by the FrtIndexWriter */
+        FRT_REF(self->analyzer);
+        self->iw = frt_iw_open(self->store, self->analyzer, false);
+        self->iw->config.use_compound_file = self->config.use_compound_file;
+    }
+}
+
+void frt_ensure_reader_open(FrtIndex *self)
+{
+    if (self->ir) {
+        if (self->check_latest && !frt_ir_is_latest(self->ir)) {
+            INDEX_CLOSE_READER(self);
+            self->ir = frt_ir_open(self->store);
+        }
+        return;
+    }
+    if (self->iw) {
+        frt_iw_close(self->iw);
+        self->iw = NULL;
+    }
+    self->ir = frt_ir_open(self->store);
+}
+
+void frt_ensure_searcher_open(FrtIndex *self)
+{
+    frt_ensure_reader_open(self);
+    if (!self->sea) {
+        self->sea = frt_isea_new(self->ir);
+    }
+}
+
+int frt_index_size(FrtIndex *self)
+{
+    int size;
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_reader_open(self);
+        size = self->ir->num_docs(self->ir);
+    }
+    frt_mutex_unlock(&self->mutex);
+    return size;
+}
+
+void frt_index_optimize(FrtIndex *self)
+{
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_writer_open(self);
+        frt_iw_optimize(self->iw);
+        AUTOFLUSH_IW(self);
+    }
+    frt_mutex_unlock(&self->mutex);
+}
+
+bool frt_index_is_deleted(FrtIndex *self, int doc_num)
+{
+    bool is_del;
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_reader_open(self);
+        is_del = self->ir->is_deleted(self->ir, doc_num);
+    }
+    frt_mutex_unlock(&self->mutex);
+    return is_del;
+}
+
+static void index_del_doc_with_key_i(FrtIndex *self, FrtDocument *doc,
+                                            FrtHashSet *key)
+{
+    FrtQuery *q;
+    FrtTopDocs *td;
+    FrtDocField *df;
+    FrtHashSetEntry *hse;
+
+    if (key->size == 1) {
+        FrtSymbol field = (FrtSymbol)key->first->elem;
+        frt_ensure_writer_open(self);
+        df = frt_doc_get_field(doc, field);
+        if (df) {
+            frt_iw_delete_term(self->iw, field, df->data[0]);
+        }
+        return;
+    }
+
+    q = frt_bq_new(false);
+    frt_ensure_searcher_open(self);
+
+    for (hse = key->first; hse; hse = hse->next) {
+        FrtSymbol field = (FrtSymbol)hse->elem;
+        df = frt_doc_get_field(doc, field);
+        if (!df) continue;
+        frt_bq_add_query(q, frt_tq_new(field, df->data[0]), FRT_BC_MUST);
+    }
+    td = frt_searcher_search(self->sea, q, 0, 1, NULL, NULL, NULL);
+    if (td->total_hits > 1) {
+        frt_td_destroy(td);
+        FRT_RAISE(FRT_ARG_ERROR, "%s", NON_UNIQUE_KEY_ERROR_MSG);
+    } else if (td->total_hits == 1) {
+        frt_ir_delete_doc(self->ir, td->hits[0]->doc);
+    }
+    frt_q_deref(q);
+    frt_td_destroy(td);
+}
+
+static void index_add_doc_i(FrtIndex *self, FrtDocument *doc)
+{
+    if (self->key) {
+        index_del_doc_with_key_i(self, doc, self->key);
+    }
+    frt_ensure_writer_open(self);
+    frt_iw_add_doc(self->iw, doc);
+    AUTOFLUSH_IW(self);
+}
+
+void frt_index_add_doc(FrtIndex *self, FrtDocument *doc)
+{
+    frt_mutex_lock(&self->mutex);
+    {
+        index_add_doc_i(self, doc);
+    }
+    frt_mutex_unlock(&self->mutex);
+}
+
+FrtQuery *frt_index_get_query(FrtIndex *self, char *qstr)
+{
+    int i;
+    FrtFieldInfos *fis;
+    frt_ensure_searcher_open(self);
+    fis = self->ir->fis;
+    for (i = fis->size - 1; i >= 0; i--) {
+        frt_hs_add(self->qp->all_fields, (void *)fis->fields[i]->name);
+    }
+    return qp_parse(self->qp, qstr);
+}
+
+FrtTopDocs *frt_index_search_str(FrtIndex *self, char *qstr, int first_doc,
+                          int num_docs, FrtFilter *filter, FrtSort *sort,
+                          FrtPostFilter *post_filter)
+{
+    FrtQuery *query;
+    FrtTopDocs *td;
+    query = frt_index_get_query(self, qstr); /* will ensure_searcher is open */
+    td = frt_searcher_search(self->sea, query, first_doc, num_docs,
+                         filter, sort, post_filter);
+    frt_q_deref(query);
+    return td;
+}
+
+FrtDocument *frt_index_get_doc(FrtIndex *self, int doc_num)
+{
+    FrtDocument *doc;
+    frt_ensure_reader_open(self);
+    doc = self->ir->get_doc(self->ir, doc_num);
+    return doc;
+}
+
+FrtDocument *frt_index_get_doc_ts(FrtIndex *self, int doc_num)
+{
+    FrtDocument *doc;
+    frt_mutex_lock(&self->mutex);
+    {
+        doc = frt_index_get_doc(self, doc_num);
+    }
+    frt_mutex_unlock(&self->mutex);
+    return doc;
+}
+
+FrtDocument *frt_index_get_doc_term(FrtIndex *self, FrtSymbol field,
+                             const char *term)
+{
+    FrtDocument *doc = NULL;
+    FrtTermDocEnum *tde;
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_reader_open(self);
+        tde = ir_term_docs_for(self->ir, field, term);
+        if (tde->next(tde)) {
+            doc = frt_index_get_doc(self, tde->doc_num(tde));
+        }
+        tde->close(tde);
+    }
+    frt_mutex_unlock(&self->mutex);
+    return doc;
+}
+
+FrtDocument *frt_index_get_doc_id(FrtIndex *self, const char *id)
+{
+    return frt_index_get_doc_term(self, self->id_field, id);
+}
+
+void frt_index_delete(FrtIndex *self, int doc_num)
+{
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_reader_open(self);
+        frt_ir_delete_doc(self->ir, doc_num);
+        AUTOFLUSH_IR(self);
+    }
+    frt_mutex_unlock(&self->mutex);
+}
+
+void frt_index_delete_term(FrtIndex *self, FrtSymbol field, const char *term)
+{
+    FrtTermDocEnum *tde;
+    frt_mutex_lock(&self->mutex);
+    {
+        if (self->ir) {
+            tde = ir_term_docs_for(self->ir, field, term);
+            FRT_TRY
+                while (tde->next(tde)) {
+                    frt_ir_delete_doc(self->ir, tde->doc_num(tde));
+                    AUTOFLUSH_IR(self);
+                }
+            FRT_XFINALLY
+                tde->close(tde);
+            FRT_XENDTRY
+        } else {
+            frt_ensure_writer_open(self);
+            frt_iw_delete_term(self->iw, field, term);
+        }
+    }
+    frt_mutex_unlock(&self->mutex);
+}
+
+void frt_index_delete_id(FrtIndex *self, const char *id)
+{
+    frt_index_delete_term(self, self->id_field, id);
+}
+
+static void index_qdel_i(FrtSearcher *sea, int doc_num, float score, void *arg)
+{
+    (void)score; (void)arg;
+    frt_ir_delete_doc(((FrtIndexSearcher *)sea)->ir, doc_num);
+}
+
+void frt_index_delete_query(FrtIndex *self, FrtQuery *q, FrtFilter *f,
+                        FrtPostFilter *post_filter)
+{
+    frt_mutex_lock(&self->mutex);
+    {
+        frt_ensure_searcher_open(self);
+        frt_searcher_search_each(self->sea, q, f, post_filter, &index_qdel_i, 0);
+        AUTOFLUSH_IR(self);
+    }
+    frt_mutex_unlock(&self->mutex);
+}
+
+void frt_index_delete_query_str(FrtIndex *self, char *qstr, FrtFilter *f,
+                            FrtPostFilter *post_filter)
+{
+    FrtQuery *q = frt_index_get_query(self, qstr);
+    frt_index_delete_query(self, q, f, post_filter);
+    frt_q_deref(q);
+}

data/ext/isomorfeus_ferret_ext/frt_ind.h

@@ -0,0 +1,54 @@
+#ifndef FRT_IND_H
+#define FRT_IND_H
+
+#include "frt_search.h"
+#include "frt_index.h"
+
+/***************************************************************************
+ *
+ * FrtIndex
+ *
+ ***************************************************************************/
+
+typedef struct FrtIndex
+{
+    FrtConfig config;
+    frt_mutex_t mutex;
+    FrtStore *store;
+    FrtAnalyzer *analyzer;
+    FrtIndexReader *ir;
+    FrtIndexWriter *iw;
+    FrtSearcher *sea;
+    FrtQParser *qp;
+    FrtHashSet *key;
+    FrtSymbol id_field;
+    FrtSymbol def_field;
+    /* for FrtIndexWriter */
+    bool auto_flush : 1;
+    bool has_writes : 1;
+    bool check_latest : 1;
+} FrtIndex;
+
+extern FrtIndex *frt_index_new(FrtStore *store, FrtAnalyzer *analyzer, FrtHashSet *def_fields, bool create);
+extern void frt_index_destroy(FrtIndex *self);
+extern int frt_index_size(FrtIndex *self);
+extern void frt_index_optimize(FrtIndex *self);
+extern bool frt_index_is_deleted(FrtIndex *self, int doc_num);
+extern void frt_index_add_doc(FrtIndex *self, FrtDocument *doc);
+extern FrtTopDocs *frt_index_search_str(FrtIndex *self, char *query, int first_doc, int num_docs, FrtFilter *filter, FrtSort *sort, FrtPostFilter *post_filter);
+extern FrtQuery *frt_index_get_query(FrtIndex *self, char *qstr);
+extern FrtDocument *frt_index_get_doc(FrtIndex *self, int doc_num);
+extern FrtDocument *frt_index_get_doc_ts(FrtIndex *self, int doc_num);
+extern FrtDocument *frt_index_get_doc_id(FrtIndex *self, const char *id);
+extern FrtDocument *frt_index_get_doc_term(FrtIndex *self, FrtSymbol field, const char *term);
+extern void frt_index_delete(FrtIndex *self, int doc_num);
+extern void frt_index_delete_term(FrtIndex *self, FrtSymbol field, const char *term);
+extern void frt_index_delete_id(FrtIndex *self, const char *id);
+extern void frt_index_delete_query(FrtIndex *self, FrtQuery *q, FrtFilter *f, FrtPostFilter *pf);
+extern void frt_index_delete_query_str(FrtIndex *self, char *qstr,FrtFilter *f, FrtPostFilter *pf);
+
+extern void frt_ensure_searcher_open(FrtIndex *self);
+extern void frt_ensure_reader_open(FrtIndex *self);
+extern void frt_ensure_writer_open(FrtIndex *self);
+
+#endif