index_db.c

Go to the documentation of this file.

/*
 * File Name: index_db.c
 */

/*
 * This file is part of ctb.
 *
 * ctb is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * ctb is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

#include "config.h"
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "log.h"
#include "index_db.h"

// maximum time to wait for a database transaction (seconds)
#define MAX_WAIT_DATABASE (30)


int db_open_global (db_state_t *db_state, const gchar *directory)
{
    LOGPRINTF("entry: dir [%s]", directory);
    
    db_state->mdb = NULL;
    db_state->transaction_started = FALSE;
    db_state->values = NULL;
    db_state->db = NULL;
    db_state->num_rows = 0;
    db_state->num_cols = 0;
    db_state->row = 0;

    erMetadb db = ermetadb_global_open(directory, FALSE);
    if (db == NULL) {
        ERRORPRINTF("failed to open database in %s.", directory);
        return ER_FAIL;
    }
    
    db_state->mdb = db;
    return ER_OK;
}


void db_close (db_state_t *db_state)
{
    LOGPRINTF("entry");

    if (db_state->mdb)
    {
        ermetadb_close(db_state->mdb);
        db_state->mdb = NULL;
    }
}


int db_start_transaction (db_state_t *db_state)
{
    int           ret = ER_OK;    // return code
    const time_t  start = time(NULL);

    LOGPRINTF("entry");

    if (db_state->mdb)
    {
        if (db_state->transaction_started)
            WARNPRINTF("transaction already started");
        ret = ermetadb_begin_transaction(db_state->mdb);
        if (ret == ERMETADB_DATABASE_BUSY)
        {
            // database locked, wait till database becomes available
            while ((ret == ERMETADB_DATABASE_BUSY) &&
                   (time(NULL) - start) <= MAX_WAIT_DATABASE )
            {
                WARNPRINTF("database locked");
                ret = ermetadb_begin_transaction(db_state->mdb);
            }
        }
    }

    db_state->transaction_started = TRUE;

    return ret;
}

// end a database transaction
int db_end_transaction (db_state_t *db_state)
{
    int  ret = ER_OK;    // return code

    LOGPRINTF("entry");

    if (db_state->transaction_started && db_state->mdb)
    {
        ret = ermetadb_end_transaction(db_state->mdb);
        db_state->transaction_started = FALSE;
    }

    return ret;
}


void db_update_entry(db_state_t *db_state, const db_entry_t* entry)
{
    ermetadb_global_update_size(db_state->mdb, entry->file_id, entry->last_modified, entry->filesize);
}


void db_update_shortcut_entry(db_state_t *db_state, const db_entry_t* entry, const char* display_name, const char* author)
{
    ermetadb_global_update_title(db_state->mdb, entry->file_id, display_name, author);
}


void db_add_entry(db_state_t *db_state, const db_entry_t* entry, const char* tag, const char* display_name, const char* author)
{
    if (entry->is_dir) {
        ermetadb_global_add_folder(db_state->mdb,
                                   entry->filepath,
                                   entry->filename,
                                   entry->last_modified);
    } else {
        if (display_name == NULL) display_name = entry->filename;
        ermetadb_global_add_file(db_state->mdb,
                                 entry->filepath,
                                 entry->filename,
                                 entry->filesize,
                                 entry->last_modified,
                                 display_name,
                                 author,
                                 tag);
    }
}


int db_delete_entry(db_state_t *db_state, const db_entry_t *entry)
{
    // NOTE: only need to delete entry itself, not subdirs/files
    return ermetadb_global_remove_entry(db_state->mdb,
                                        entry->file_id,
                                        entry->filepath,
                                        entry->filename,
                                        entry->is_dir);
}


static db_entry_t* row2entry(const metadata_cell *row)
{
    // SQL result: file_id, filename, dirpath, isdir, size, date
    db_entry_t* entry = g_malloc(sizeof(db_entry_t));
    memset(entry, 0, sizeof(db_entry_t));

    const metadata_cell *cell = row;
    gint64 file_id = cell->value.v_int64;
    entry->file_id = file_id;

    cell++;
    char* filename = cell->value.v_text->str;
    entry->filename = filename;

    cell++;
    char* filepath = cell->value.v_text->str;
    entry->filepath = filepath;

    cell++;
    gboolean is_dir = cell->value.v_int64;
    entry->is_dir = is_dir;

    cell++;
    gint64 size = cell->value.v_int64;
    entry->filesize = size;

    cell++;
    gint64 filedate = cell->value.v_int64;
    entry->last_modified = filedate;

    return entry;
}


GSList* db_get_model(const gchar* dir)
{
    db_state_t db_state;
    GSList* model = 0;

    if (db_open_global(&db_state, dir) != ER_OK) {
        ERRORPRINTF("error opening db");
        return NULL;
    }

    metadata_table *values = NULL;

    int ret = ermetadb_global_select_all(db_state.mdb, &values);
    if (ret != ER_OK) {
        ERRORPRINTF("error [%d]", ret);
        goto out;
    }

    int n_rows = metadata_table_n_rows(values);
    int n_cols = metadata_table_n_columns(values);

    const metadata_cell *row = (const metadata_cell*) (values->cell_data->data);
    for (int i=0; i<n_rows; i++) {
        db_entry_t* entry = row2entry(row);
        model = g_slist_prepend(model, entry);
        row += n_cols; 
    }

    model = g_slist_reverse(model);
    
    // DONT FREE, strings are used
    //metadata_table_free(values);
out:
    db_close(&db_state);
    return model;
}