metadata_table.c

Go to the documentation of this file.

/*
 * File Name: metadata_table.c
 */

/*
 * This file is part of libermetadb.
 *
 * libermetadb 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.
 *
 * libermetadb 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) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <string.h>

// ereader include files, between < >
#include <liberutils/er_error.h>

// local include files, between " "
#define LOGGING_ON 0
#include "ermetadb_log.h"
#include "metadata_table.h"
#include "metadata_table_private.h"


//============================================================================
// Functions Implementation
//============================================================================

metadata_table *metadata_table_new (void)
{
    metadata_table *thiz = g_new0(metadata_table, 1);
    g_assert(thiz);
    thiz->n_rows    = 0;
    thiz->n_columns = 0;
    thiz->cell_data = g_array_new(TRUE, TRUE, sizeof(metadata_cell));
#if METADATA_NULL != 0x00
# error  METADATA_NULL must have value 0x00
# error    new entries in the metadata_table->cell_data array are initialised to 0x00,
# error    which is assumed to set the metadata_cell.type to METADATA_NULL
#endif
    return thiz;
}


void metadata_table_free_impl (metadata_table *thiz)
{
    if (thiz == NULL) return;
    g_return_if_fail(thiz->cell_data);

    // clear all cells
    metadata_cell *cell = &g_array_index(thiz->cell_data, metadata_cell, 0);
    unsigned int i;
    for (i = 0 ; i < thiz->cell_data->len ; i++, cell++)
    {
        metadata_cell_clear(cell);
    }

    g_array_free(thiz->cell_data, TRUE);
    g_free(thiz);
}


void metadata_table_dump_impl (const metadata_table *thiz)
{
    LOGPRINTF("entry: thiz [%p]", thiz);
    if (thiz == NULL) return;

    int n_rows = metadata_table_n_rows(thiz);
    int n_cols = metadata_table_n_columns(thiz);
    GString *dump = g_string_new("");

    // print column names
    int col;
    for (col = 0; col < n_cols ; col++)
    {
        const metadata_cell *cell = metadata_table_get_cell(thiz, col);
        if (cell->name  &&  cell->name->str)
        {
            g_string_append(dump, cell->name->str);
        }
        g_string_append_c(dump, '|');
    }
    QUERYPRINTF("%s", dump->str);

    // print row values
    int row;
    for (row = 0 ; row < n_rows ; row++)
    {
        g_string_set_size(dump, 0);
        for (col = 0; col < n_cols ; col++)
        {
            GString *value = metadata_table_get_string(thiz, metadata_table_cell_index(thiz, row, col));
            if (value  &&  value->str)
            {
                g_string_append(dump, value->str);
                g_string_free(value, TRUE);
            }
            g_string_append_c(dump, '|');
        }
        QUERYPRINTF("%s", dump->str);
    }

    g_string_free(dump, TRUE);
}


int metadata_table_add_column (metadata_table *thiz, const char *name)
{
    LOGPRINTF("entry: thiz [%p] name [%s]", thiz, name);

    g_return_val_if_fail(thiz,                ER_INVALID_PARAMETER);
    g_return_val_if_fail(name,                ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_rows <= 1), ER_INVALID_PARAMETER);

    // add column
    thiz->n_columns++;
    guint n_col = thiz->n_columns;
    g_array_set_size(thiz->cell_data, n_col);

    // set name
    metadata_cell *cell = &g_array_index(thiz->cell_data, metadata_cell, n_col - 1);
    metadata_cell_set_name(cell, name);

    return ER_OK;
}


int metadata_table_find_column (const metadata_table *thiz, const char *name)
{
    LOGPRINTF("entry: thiz [%p] name [%s]", thiz, name);
    g_assert(thiz);
    g_assert(name);

    metadata_cell *cell = &g_array_index(thiz->cell_data, metadata_cell, 0);
    unsigned int i;
    for (i = 0 ; i < thiz->n_columns; i++, cell++)
    {
        if (strcmp(name, cell->name->str) == 0)
        {
            return i;
        }
    }

    return -1;
}


// expand table, ensure at least cells  0 ... <idx>  are present
static void metadata_table_add_rows (metadata_table *thiz, const guint idx)
{
    guint n_rows = thiz->n_rows;
    const guint n_columns = thiz->n_columns;

    LOGPRINTF("entry: thiz [%p] idx [%d]", thiz, idx);

    // add cells to table, when needed
    guint n_cells_old = thiz->cell_data->len;
    if (idx >= n_cells_old)
    {
        if (n_columns == 0)
        {
            // no columns: allocate the requested number of cells
            g_array_set_size(thiz->cell_data, idx + 1);
        }
        else
        {
            // table has columns: allocate complete rows
            {
                n_rows      = 1 + (idx / n_columns);
                guint n_cells_new = n_rows * n_columns;

                g_array_set_size(thiz->cell_data, n_cells_new);
            }
        }
    }

    // set current number of rows
    // note: n_rows is zero for a table that has columns defined but no data yet,
    //       therefore we must set n_rows even when no new cells are added
    if (n_columns)
    {
        n_rows = thiz->cell_data->len / n_columns;
    }
    else
    {
        n_rows = thiz->cell_data->len;
    }
    thiz->n_rows = n_rows;
}


static metadata_cell *add_row_if_needed(metadata_table *thiz, guint idx)
{
    // add row(s) to table, when needed
    metadata_table_add_rows(thiz, idx);
    metadata_cell *cell = &g_array_index(thiz->cell_data, metadata_cell, idx);
    metadata_cell_clear_value(cell);
    return cell;
}


int metadata_table_set_value (metadata_table *thiz, const guint idx, const sqlite3_value *value)
{
    LOGPRINTF("entry: thiz [%p] idx [%d]", thiz, idx);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);
    
    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_value(cell, value);
}


int metadata_table_set_int64 (metadata_table *thiz, const guint idx, const gint64 value)
{
    LOGPRINTF("entry: thiz [%p] idx [%d] value [%lld]", thiz, idx, value);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_int64(cell, value);
}


int metadata_table_set_double (metadata_table *thiz, const guint idx, const double value)
{
    LOGPRINTF("entry: thiz [%p] idx [%d] value [%f]", thiz, idx, value);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_double(cell, value);
}


int metadata_table_set_text (metadata_table *thiz, const guint idx, const char *value)
{
    LOGPRINTF("entry: thiz [%p] idx [%d] value [%s]", thiz, idx, value);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);
    g_return_val_if_fail( value,                ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_text(cell, value);
}


int metadata_table_set_blob (metadata_table *thiz, const guint idx, gchar *value, const guint len)
{
    LOGPRINTF("entry: thiz [%p] idx [%d] value [%p]", thiz, idx, value);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);
    g_return_val_if_fail( value,                ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_blob(cell, value, len);
}


int metadata_table_set_blob_static (metadata_table *thiz, const guint idx, const gchar *value, const guint len)
{
    LOGPRINTF("entry: thiz [%p] idx [%d] value [%p]", thiz, idx, value);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);
    g_return_val_if_fail( value,                ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_set_blob_static(cell, value, len);
}


int metadata_table_set_cell (metadata_table *thiz, const guint idx, const metadata_cell *value)
{
    LOGPRINTF("entry: thiz [%p] idx [%d]", thiz, idx);

    g_return_val_if_fail( thiz,                 ER_INVALID_PARAMETER);
    g_return_val_if_fail((thiz->n_columns > 0), ER_INVALID_PARAMETER);
    g_return_val_if_fail( value,                ER_INVALID_PARAMETER);

    metadata_cell *cell = add_row_if_needed(thiz, idx);
    return metadata_cell_copy_value(cell, value);
}


const metadata_cell* metadata_table_get_cell (const metadata_table *thiz, const guint idx)
{
    LOGPRINTF("entry: thiz [%p] idx [%d]", thiz, idx);
    g_return_val_if_fail(thiz,                         NULL);
    g_return_val_if_fail(thiz->cell_data,              NULL);

    if (idx < thiz->cell_data->len)
    {
        // report cell
        const metadata_cell *cell = &g_array_index(thiz->cell_data, metadata_cell, idx);
        return cell;
    }

    return NULL;
}


GString* metadata_table_get_string (const metadata_table *thiz, const guint idx)
{
    LOGPRINTF("entry: thiz [%p] idx [%d]", thiz, idx);

    const metadata_cell *cell = metadata_table_get_cell(thiz, idx);
    if (cell == NULL)
    {
        ERRORPRINTF("cannot find cell: thiz [%p] idx [%u]", thiz, idx);
        return NULL;
    }
    else
    {
        return metadata_cell_get_string(cell);
    }
}