root/lang/perl/Senna/trunk/senna-index.c @ 3915

/* $Id$
 *
 * Copyright (c) 2005-2007 Daisuke Maki <daisuke@endeworks.jp>
 * All rights reserved.
 */
#ifndef  __SENNA_INDEX_C__
#define  __SENNA_INDEX_C__
#include "senna-perl.h"

int
SennaPerl_Index_bootstrap()
{
    HV *stash;

    stash = gv_stashpv("Senna::Costants", 1);

    newCONSTSUB(stash, "SEN_INDEX_NORMALIZE", newSViv(SEN_INDEX_NORMALIZE));
    newCONSTSUB(stash, "SEN_INDEX_SPLIT_ALPHA", newSViv(SEN_INDEX_SPLIT_ALPHA));
    newCONSTSUB(stash, "SEN_INDEX_SPLIT_DIGIT", newSViv(SEN_INDEX_SPLIT_DIGIT));
    newCONSTSUB(stash, "SEN_INDEX_SPLIT_SYMBOL",
        newSViv(SEN_INDEX_SPLIT_SYMBOL));
    newCONSTSUB(stash, "SEN_INDEX_MORPH_ANALYSE",
        newSViv(SEN_INDEX_MORPH_ANALYSE));
    newCONSTSUB(stash, "SEN_INDEX_NGRAM", newSViv(SEN_INDEX_NGRAM));
    newCONSTSUB(stash, "SEN_INDEX_DELIMITED", newSViv(SEN_INDEX_DELIMITED));
    newCONSTSUB(stash, "SEN_INDEX_ENABLE_SUFFIX_SEARCH",
        newSViv(SEN_INDEX_ENABLE_SUFFIX_SEARCH));
    newCONSTSUB(stash, "SEN_INDEX_DISABLE_SUFFIX_SEARCH",
        newSViv(SEN_INDEX_DISABLE_SUFFIX_SEARCH));
    newCONSTSUB(stash, "SEN_INDEX_WITH_VACUUM", newSViv(SEN_INDEX_WITH_VACUUM));

    return 1;
}

SV *
SennaPerl_Index_new(pkg, index)
        char *pkg;
        sen_index *index;
{
    SennaPerl_Index *xs;
    SV *sv;

    Newz(1234, xs, 1, SennaPerl_Index);

    xs->index = index;
    xs->open  = TRUE;

    XS_STRUCT2OBJ(sv, pkg, xs);
    SvREADONLY_on(sv);
    return sv;
}

SV *
SennaPerl_Index_XS_create(pkg, path, key_size, flags, initial_n_segments, encoding)
        char *pkg;
        char *path;
        int   key_size;
        int   flags;
        int   initial_n_segments;
        sen_encoding encoding;
{
    sen_index *index;
    SV        *sv;
    
    index = sen_index_create(path, key_size, flags, initial_n_segments, encoding);
    if (index == NULL) {
        croak("Failed to create senna index (sen_index_create() returned NULL) ");
    }

    return SennaPerl_Index_new(pkg, index);
}

SV *
SennaPerl_Index_open(pkg, path)
        char *pkg;
        char *path;
{
    sen_index *index;
    int        key_size;
    SV        *sv;

    index = sen_index_open(path);
    if (index == NULL) {
        croak("Failed to open senna index %s.", path);
    }

    sv = SennaPerl_Index_new(pkg, index);
    return sv;
}

SV *
SennaPerl_Index_remove(self)
        SV *self;
{
    SennaPerl_Index *index;
    char       path[ SEN_MAX_PATH_SIZE ];

    index = XS_STATE(SennaPerl_Index *, self);
    if (! sen_index_path( index->index, path, SEN_MAX_PATH_SIZE) ) {
        croak("sen_index_path() did not return a proper path");
    }

    return sen_rc2obj( sen_index_remove( path ) );
}

SV *
SennaPerl_Index_close(obj)
        SV *obj;
{
    SennaPerl_Index *index;
    index = XS_STATE(SennaPerl_Index *, obj);
    if (index == NULL || ! index->open) {
        return SennaPerl_Global_sen_rc2obj( sen_other_error );
    } else {
        index->open = FALSE;
        return SennaPerl_Global_sen_rc2obj( sen_index_close(index->index) );
    }
}

void
SennaPerl_Index_DESTROY(obj)
        SV *obj;
{
    SennaPerl_Index *index;
    index = XS_STATE(SennaPerl_Index *, obj);

    SennaPerl_Index_close(obj);
    Safefree(index);
}

SV *
SennaPerl_Index_path(obj)
        SV *obj;
{
    SennaPerl_Index *index;
    char *buf;
    SV *sv;

    index = XS_STATE(SennaPerl_Index *, obj);
    buf = malloc(sizeof(char) * SEN_MAX_PATH_SIZE);

    sen_index_path(index->index, buf, SEN_MAX_PATH_SIZE);
    sv = newSVpv( buf, strlen(buf) );
    free(buf);
    return sv;
}

SV *
SennaPerl_Index_update(obj, key, oldvalue, newvalue)
        SV *obj;
        SV *key;
        SV *oldvalue;
        SV *newvalue;
{
    SennaPerl_Index *index = XS_STATE(SennaPerl_Index *, obj);
    void *pkey = SennaPerl_Global_sv2key(key);
    char *oldc = NULL;
    char *newc = NULL;
    STRLEN oldl = 0;
    STRLEN newl = 0;

    /* XXX - Do we need to use SvPVbyte here? */
    if ( oldvalue != NULL && SvPOK(oldvalue)) {
        oldc = SvPV(oldvalue, oldl);
    }

    if ( newvalue != NULL && SvPOK(newvalue)) {
        newc = SvPV(newvalue, newl);
    }

    return sen_rc2obj( 
        sen_index_upd( index->index, pkey, oldc, oldl, newc, newl )
    );
}

SV *
SennaPerl_Index_insert(obj, key, value)
        SV *obj;
        SV *key;
        SV *value;
{
    return SennaPerl_Index_update(obj, key, NULL, value);
}

SV *
SennaPerl_Index_select(obj, query)
        SV *obj;
        SV *query;
{
    sen_rc rc;
    char *string;
    STRLEN string_len;
    sen_records *records = sen_records_open(sen_rec_document, sen_rec_none, 0);
    sen_sel_operator op;
    sen_select_optarg *optarg = NULL;
    SennaPerl_Index *index = XS_STATE(SennaPerl_Index *, obj);

    if (query == NULL || ! SvOK(query)) {
        return &PL_sv_undef;
    }
    string = SvPV(query, string_len);

    rc = sen_index_select(index->index, string, string_len, records, op, optarg);
    if (rc != sen_success) {
        sen_records_close(records);
        croak("sen_index_select() failed");
    }

    return SennaPerl_Records_new("Senna::Records", records);
}

#endif /*  __SENNA_INDEX_C__ */