sqlite3_wrapper.c File Reference

#include <glib.h>
#include <sqlite3.h>
#include <sys/types.h>
#include <unistd.h>
#include <liberutils/er_error.h>
#include "ermetadb_log.h"
#include "ermetadb.h"
#include "ermetadb_error.h"
#include "ermetadb_private.h"
#include "metadata_table.h"
#include "metadata_table_private.h"
#include "sqlite3_wrapper.h"

Include dependency graph for sqlite3_wrapper.c:

Go to the source code of this file.

Defines
#define	LOGGING_ON   0
#define	UNUSED(x)   (void)(x)
Functions
static void	sql3_finalize_statements (GPtrArray *statements)
	Release compiled sql statements.
static int	sql3_prepare_statements (sqlite3 *db, const char *sql, GPtrArray **statements)
	Parse sql string and compile into byte code.
static void	bind_single_statement (void *p1, void *p2)
int	sql3_bind_parameters (GPtrArray *statements, const metadata_table *parameters)
	Bind positional parameters to a set of compiled sql statements Assumes no parameters are currently bound to this statement Assumes TEXT and BLOB parameters unchanged until statements have executed.
static metadata_table *	create_result_table (sqlite3_stmt *stmt)
static int	execute_single_statement (sqlite3_stmt *stmt, metadata_table **result_table)
static int	sql3_execute_statements (sqlite3 *db, const GPtrArray *statements, metadata_table **result_table)
	Parse sql string and compile into byte code.
int	sql3_execute_query (sqlite3 *db, const char *sql, const metadata_table *parameters, metadata_table **result_table)
	Execute sql query. A convenience wrapper around sql3_prepare_statements(), sql3_execute_statements(), sql3_finalize_statements() for queries that have no parameters.
static int	begin_transaction (erMetadb thiz, const gboolean is_readonly)
int	sql3_begin_transaction (erMetadb thiz)
	Start a database transaction. Transactions may be nested, as long as the calls to sql3_begin_transaction() and sql3_begin_transaction_readonly() are balanced with calls to sql3_commit_or_rollback.
int	sql3_begin_transaction_readonly (erMetadb thiz)
	Start a read-only database transaction. Transactions may be nested, as long as the calls to sql3_begin_transaction() and sql3_begin_transaction_readonly() are balanced with calls to sql3_commit_or_rollback.
int	sql3_commit_or_rollback (erMetadb thiz, int err)
	Commit or rollback a database transaction Transactions may be nested, as long as the calls to sql3_begin_transaction() are balanced with calls to sql3_commit_or_rollback. Superfluous calls to sql3_commit_or_rollback are allowed.
int	sql3_strcase_compare (void *user_data, int left_len, const void *left_void, int right_len, const void *right_void)
	Compare function to be used in custom collation sequence See documentation on sqlite3_create_collation() for details.
Variables
static const int	BEGIN_MAX_RETRIES = 20
static const int	BEGIN_RETRY_MS = 250
static const int	COMMIT_MAX_RETRIES = 30
static const int	COMMIT_RETRY_MS = 100
static const int	STEP_MAX_RETRIES = 10
static const int	STEP_RETRY_MS = 100

---

Define Documentation

#define LOGGING_ON   0

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Definition at line 41 of file sqlite3_wrapper.c.

#define UNUSED

(

x

)

(void)(x)

Definition at line 50 of file sqlite3_wrapper.c.

---

Function Documentation

static int begin_transaction	(	erMetadb	thiz,
		const gboolean	is_readonly
	)			[static]

Definition at line 511 of file sqlite3_wrapper.c.

References BEGIN_MAX_RETRIES, BEGIN_RETRY_MS, ER_INVALID_PARAMETER, ER_OK, ER_READONLY, ERMETADB_DATABASE_BUSY, ERMETADB_FAIL, ERRORPRINTF, LOGPRINTF, QUERYPRINTF, and WARNPRINTF.

Referenced by sql3_begin_transaction(), and sql3_begin_transaction_readonly().

{
    int         ret = ER_OK;
    int         rc;
    const char  *sql    = NULL;
    char        *errmsg = NULL;
    int         retries_left = BEGIN_MAX_RETRIES;
    gboolean    done = FALSE;

    g_assert(thiz && thiz->database);
    g_assert(thiz->transaction_nesting < 100);

    sqlite3 *db = thiz->database;

    LOGPRINTF( "entry: db [%p] is_readonly [%d] [%d] transaction_nesting [%d]",
                db,
                is_readonly,
                thiz->is_transaction_readonly,
                thiz->transaction_nesting      );

    g_return_val_if_fail(db, ER_INVALID_PARAMETER);


    // start a transaction, acquire write lock
    if (thiz->transaction_nesting == 0)
    {
        thiz->is_transaction_readonly = is_readonly;
        thiz->do_force_rollback       = FALSE;

        // repeat while database locked
        if ( is_readonly )
        {
            sql = "BEGIN DEFERRED;";
        }
        else
        {
            sql = "BEGIN IMMEDIATE;";
        }
        QUERYPRINTF("sql [%s]", sql);
        while (!done)
        {
            rc = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
            if (rc == SQLITE_OK)
            {
                // database lock obtained: increase transaction nesting level
                thiz->transaction_nesting++;
                done = TRUE;

            }
            else if (   rc == SQLITE_BUSY
                     && --retries_left >= 0 )
            {
                // database locked: wait a while then try again
                WARNPRINTF("pid [%ld] waiting for database lock", (long)getpid());
                usleep(BEGIN_RETRY_MS * 1000);
            }
            else
            {
                ERRORPRINTF("pid [%ld] cannot begin transaction, error [%d] [%s]", (long)getpid(), rc, errmsg);
                switch (rc)
                {
                    case SQLITE_BUSY:
                        ret = ERMETADB_DATABASE_BUSY;
                        break;
                    case SQLITE_READONLY:
                        ret = ER_READONLY;
                        break;
                    default:
                        ret = ERMETADB_FAIL;
                }
                done = TRUE;
            }

            // free error message, if any
            sqlite3_free(errmsg);
            errmsg = NULL;
        }
    }
    else
    {
        // transaction in progress: check read-only status
        if ( is_readonly == thiz->is_transaction_readonly )
        {
            // same is_readonly: ok
            thiz->transaction_nesting++;
        }
        else if ( is_readonly )
        {
            // read-only begin on writable transaction: ok
            thiz->transaction_nesting++;
        }
        else
        {
            // error: read-only transaction cannot be promoted to writable
            ret = ER_READONLY;
        }
    }

    if (ret != ER_OK) WARNPRINTF("cannot begin transaction. ret [%d]", ret);
    return ret;
}

Here is the caller graph for this function:

static void bind_single_statement	(	void *	p1,
		void *	p2
	)			[static]

Definition at line 185 of file sqlite3_wrapper.c.

References ER_OK, ERRORPRINTF, LOGPRINTF, METADATA_BLOB, METADATA_DOUBLE, METADATA_INT64, METADATA_NULL, metadata_table_get_cell(), METADATA_TEXT, metadata_cell::type, metadata_cell::v_blob, metadata_cell::v_double, metadata_cell::v_int64, metadata_cell::v_text, and metadata_cell::value.

Referenced by sql3_bind_parameters().

{
    sqlite3_stmt         *stmt       = (sqlite3_stmt*)    p1;
    const metadata_table *parameters = (const metadata_table*) p2;

    LOGPRINTF("entry: stmt [%p]", stmt);

    // get #parameters in statement
    int n_parms = sqlite3_bind_parameter_count(stmt);

    // bind parameters
    GString *parm_name = g_string_new("");
    int parm_idx;
    const metadata_cell *parm = NULL;
    for (parm_idx = 0 ; parm_idx < n_parms ; parm_idx++)
    {
        // get parameter name
        g_string_printf(parm_name, "?%d", parm_idx + 1);

        // find parameter value
        metadata_cell_type parm_type = METADATA_NULL;
        if (parameters)
        {
            parm = metadata_table_get_cell(parameters, parm_idx);
            if (parm)
            {
                parm_type = parm->type;
            }
        }

        int rc;
        // bind parameter
        switch (parm_type)
        {
            case METADATA_INT64:
                rc = sqlite3_bind_int64(stmt, parm_idx + 1, parm->value.v_int64);
                break;
            case METADATA_DOUBLE:
                rc = sqlite3_bind_double(stmt, parm_idx + 1, parm->value.v_double);
                break;
            case METADATA_TEXT:
                rc = sqlite3_bind_text(stmt, parm_idx + 1, parm->value.v_text->str, -1, SQLITE_STATIC);
                break;
            case METADATA_BLOB:
                rc = sqlite3_bind_blob(stmt, parm_idx + 1, parm->value.v_blob.data, parm->value.v_blob.len, SQLITE_STATIC);
                break;
            default:
                rc = sqlite3_bind_null(stmt, parm_idx + 1);
        }
        if (rc != ER_OK)
        {
            ERRORPRINTF("sqlite3_bind_xx returns [%d] on stmt [%p]", rc, stmt);
            sqlite3_bind_null(stmt, parm_idx + 1);
        }
    }

    g_string_free(parm_name, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static metadata_table* create_result_table

(

sqlite3_stmt *

stmt

)

[static]

Definition at line 272 of file sqlite3_wrapper.c.

References ERRORPRINTF, LOGPRINTF, metadata_table_add_column(), metadata_table_new(), and name.

Referenced by execute_single_statement().

{
    metadata_table *result = metadata_table_new();
    g_assert(result);

    // add columns to result table
    int n_col = sqlite3_column_count(stmt);
    int col;
    for (col = 0 ; col < n_col ; col++)
    {
        const char* name = sqlite3_column_name(stmt, col);
        if (name == NULL)
        {
            ERRORPRINTF("sqlite3_column returns NULL");
        }
        LOGPRINTF("column [%d] name [%s]", col, name);
        metadata_table_add_column(result, name);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int execute_single_statement	(	sqlite3_stmt *	stmt,
		metadata_table **	result_table
	)			[static]

Definition at line 295 of file sqlite3_wrapper.c.

References create_result_table(), ER_OK, ERMETADB_FAIL, ERRORPRINTF, metadata_table_dump, metadata_table_free, metadata_table_n_columns, metadata_table_n_rows, metadata_table_set_value(), STEP_MAX_RETRIES, and STEP_RETRY_MS.

Referenced by sql3_execute_statements().

{
    int ret = ER_OK;

    // repeat step while new rows are delivered
    metadata_table *result = NULL;
    int retries_left = STEP_MAX_RETRIES;
    gboolean done = FALSE;
    while (!done)
    {
        int step_rc = sqlite3_step(stmt);
        switch (step_rc)
        {
            case SQLITE_ROW:
            {
                if (result == NULL) result = create_result_table(stmt);

                // read column values into result table
                int n_row = metadata_table_n_rows(result);
                int n_col = metadata_table_n_columns(result);
                int idx = n_row * n_col;
                int col;
                for (col = 0 ; col < n_col && ret == ER_OK ; col++)
                {
                    sqlite3_value *value = sqlite3_column_value(stmt, col);
                    int rc = metadata_table_set_value(result, idx, value);
                    if (rc != ER_OK)
                    {
                        ret = rc;
                        done = TRUE;
                    }
                    idx++;
                }
                retries_left = STEP_MAX_RETRIES;
                break;
            }
            case SQLITE_DONE:
                done = TRUE;
                break;

            case SQLITE_BUSY:
                if (--retries_left >= 0)
                {
                    // wait a while, then try again
                    usleep(STEP_RETRY_MS * 1000);
                    break;
                }
                else
                {
                    // no more retries: error
                    ; // FALLTHROUGH to case default
                }

            default:
                ERRORPRINTF("sqlite3_step reports error [%d]", step_rc);
                ret  = ERMETADB_FAIL;
                done = TRUE;
        }
    }

    if (result)
    {
        // report the result
        if (*result_table)
        {
            ERRORPRINTF( "Not allowed to have SQL statements produce multiple result sets.\n"
                         "Second result set discarded:" );
            metadata_table_dump(result);
            metadata_table_free(result);
            ret = ERMETADB_FAIL;
        }
        else
        {
            *result_table = result;
        }
    }

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sql3_begin_transaction

(

erMetadb

thiz

)

Start a database transaction. Transactions may be nested, as long as the calls to sql3_begin_transaction() and sql3_begin_transaction_readonly() are balanced with calls to sql3_commit_or_rollback.

---------------------------------------------------------------------------

Name : sql3_begin_transaction

Parameters:

[in]

thiz

- erMetadb object on which to start a transaction

Returns:

ER_OK or error

--------------------------------------------------------------------------

Definition at line 614 of file sqlite3_wrapper.c.

References begin_transaction().

Referenced by add_filename(), ermetadb_begin_transaction(), ermetadb_global_remove_folder(), ermetadb_local_create_annotation(), ermetadb_local_remove_application_data(), ermetadb_local_set_annotation(), ermetadb_local_set_application_data(), local_delete_all_data_for_id(), open_sql_database(), and set_file_metadata_impl().

{
    return begin_transaction(thiz, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sql3_begin_transaction_readonly

(

erMetadb

thiz

)

Start a read-only database transaction. Transactions may be nested, as long as the calls to sql3_begin_transaction() and sql3_begin_transaction_readonly() are balanced with calls to sql3_commit_or_rollback.

---------------------------------------------------------------------------

Name : sql3_begin_transaction_readonly

Parameters:

[in]

thiz

- erMetadb object on which to start a transaction

Returns:

ER_OK or error

--------------------------------------------------------------------------

Definition at line 620 of file sqlite3_wrapper.c.

References begin_transaction().

Referenced by ermetadb_begin_transaction_readonly(), ermetadb_global_get_file(), ermetadb_local_get_annotations(), ermetadb_local_get_application_data(), ermetadb_local_select_annotations(), and open_sql_database().

{
    return begin_transaction(thiz, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sql3_bind_parameters	(	GPtrArray *	statements,
		const metadata_table *	parameters
	)

Bind positional parameters to a set of compiled sql statements Assumes no parameters are currently bound to this statement Assumes TEXT and BLOB parameters unchanged until statements have executed.

---------------------------------------------------------------------------

Name : sql3_bind_parameters

Parameters:

	[in/out]	statements - GPtrArray with compiled statements
[in]	parameters	- metadata_table with parameters (value), or NULL table must have exactly one row

Returns:

ER_OK or error code

--------------------------------------------------------------------------

Definition at line 260 of file sqlite3_wrapper.c.

References bind_single_statement(), ER_INVALID_PARAMETER, and ER_OK.

Referenced by sql3_execute_query().

{
    g_return_val_if_fail( statements          , ER_INVALID_PARAMETER);
    g_return_val_if_fail((statements->len > 0), ER_INVALID_PARAMETER);

    metadata_table *parms = (metadata_table*) parameters;  // const_cast
    g_ptr_array_foreach(statements, bind_single_statement, parms);

    return ER_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sql3_commit_or_rollback	(	erMetadb	thiz,
		int	err
	)

Commit or rollback a database transaction Transactions may be nested, as long as the calls to sql3_begin_transaction() are balanced with calls to sql3_commit_or_rollback. Superfluous calls to sql3_commit_or_rollback are allowed.

---------------------------------------------------------------------------

Name : sql3_commit_or_rollback

Parameters:

[in]	thiz	- erMetadb object on which to end a transaction
[in]	err	- ER_OK or error code

Returns:

ER_OK or error or 'err' value when this is not ER_OK

--------------------------------------------------------------------------

Definition at line 626 of file sqlite3_wrapper.c.

References BEGIN_RETRY_MS, COMMIT_MAX_RETRIES, ER_OK, ERMETADB_DATABASE_BUSY, ERMETADB_FAIL, ERRORPRINTF, LOGPRINTF, QUERYPRINTF, and WARNPRINTF.

Referenced by add_filename(), ermetadb_close(), ermetadb_end_transaction(), ermetadb_global_get_file(), ermetadb_global_remove_folder(), ermetadb_global_rename_file(), ermetadb_local_create_annotation(), ermetadb_local_get_annotations(), ermetadb_local_get_application_data(), ermetadb_local_remove_application_data(), ermetadb_local_select_annotations(), ermetadb_local_set_annotation(), ermetadb_local_set_application_data(), local_delete_all_data_for_id(), open_sql_database(), and set_file_metadata_impl().

{
    g_assert(thiz && thiz->database);

    LOGPRINTF( "entry: err [%d] is_readonly [%d] transaction_nesting [%d]",
                err,
                thiz->is_transaction_readonly,
                thiz->transaction_nesting      );

    // decide whether to commit or rollback
    if (err != ER_OK) thiz->do_force_rollback = TRUE;

    // never turn an error code into a good one
    int ret = err;
    if (thiz->transaction_nesting > 0)
    {
        // decrease transaction nesting level
        thiz->transaction_nesting--;

        if (thiz->transaction_nesting == 0)
        {
            const char *sql = NULL;
            // decide commit or rollback ...
            if ( err == ER_OK && thiz->do_force_rollback == FALSE )
            {
                // ok: commit changes to database
                sql = "COMMIT;";
            }
            else
            {
                // error: rollback and return original error code
                sql = "ROLLBACK;";
            }
            QUERYPRINTF("sql [%s]", sql);

            // ... and execute it
            gboolean done = FALSE;
            int retries_left = COMMIT_MAX_RETRIES;
            while (!done)
            {
                char *errmsg = NULL;
                int rc = sqlite3_exec(thiz->database, sql, NULL, NULL, &errmsg);
                if (rc == SQLITE_OK)
                {
                    // transaction ended
                    done = TRUE;
                }
                else if ( rc == SQLITE_BUSY && --retries_left >= 0 )
                {
                    // database locked: wait a while then try again
                    WARNPRINTF("pid [%ld] waiting for database lock, sql [%s]", (long)getpid(), sql);
                    usleep(BEGIN_RETRY_MS * 1000);
                }
                else
                {
                    ERRORPRINTF("cannot end transaction, sql [%s] error [%d] [%s]", sql, rc, errmsg);
                    if (rc == SQLITE_BUSY)
                    {
                        ret = ERMETADB_DATABASE_BUSY;
                    }
                    else
                    {
                        ret = ERMETADB_FAIL;
                    }
                    done = TRUE;
                }

                // free error message, if any
                sqlite3_free(errmsg);
                errmsg = NULL;
            }
        }
    }

    LOGPRINTF("leave: ret [%d]", ret);
    return ret;
}

Here is the caller graph for this function:

int sql3_execute_query	(	sqlite3 *	db,
		const char *	sql,
		const metadata_table *	parameters,
		metadata_table **	result_table
	)

Execute sql query. A convenience wrapper around sql3_prepare_statements(), sql3_execute_statements(), sql3_finalize_statements() for queries that have no parameters.

File Name : sqlite3_wrapper.h

Description: Wrapper layer around the sqlite3 C API Copyright (C) 2008 iRex Technologies B.V. All rights reserved.---------------------------------------------------------------------------

Name : sql3_execute_query

Parameters:

[in]	db	- sqlite database object
[in]	sql	- SQL statement(s) as text
[in]	parameters	- metadata_table with parameters (value), or NULL table must have exactly one row
[in]	result_table	- location to store metadata_table holding query results, or NULL when caller is not interested in query results
[out]	result_table	- metadata_table holding query results, or NULL when no results First row holds column names and cell values, other rows hold cell values only.

Returns:

ER_OK or error code

--------------------------------------------------------------------------

Definition at line 453 of file sqlite3_wrapper.c.

References ER_INVALID_PARAMETER, ER_OK, ERRORPRINTF, metadata_table_dump, metadata_table_free, QUERYPRINTF, sql3_bind_parameters(), sql3_execute_statements(), sql3_finalize_statements(), and sql3_prepare_statements().

Referenced by add_file_ids(), add_filename(), check_database_version(), check_global_database_columns(), check_global_database_tables(), convert_database_01_06(), convert_database_05_06(), delete_entry(), ermetadb_global_get_file(), ermetadb_global_remove_folder(), ermetadb_global_rename_file(), ermetadb_global_select_all(), ermetadb_global_update_size(), ermetadb_global_update_title(), ermetadb_local_create_annotation(), ermetadb_local_get_annotations(), ermetadb_local_get_application_data(), ermetadb_local_remove_annotation(), ermetadb_local_remove_application_data(), ermetadb_local_select_annotations(), ermetadb_local_set_application_data(), find_or_create_filename(), get_global_id(), get_local_id(), global_select_common(), local_delete_all_annotations(), local_delete_all_application_data(), local_delete_entry(), open_sql_database(), set_annotation_impl(), set_file_metadata_impl(), and update_version_number().

{
    QUERYPRINTF("entry: sql [%s]", sql);
    metadata_table_dump(parameters);

    g_return_val_if_fail( db                       , ER_INVALID_PARAMETER);
    g_return_val_if_fail( sql                      , ER_INVALID_PARAMETER);
    g_return_val_if_fail((   result_table == NULL
                          || *result_table == NULL), ER_INVALID_PARAMETER);

    int ret = ER_OK;
    GPtrArray *statements = NULL;
    int rc = sql3_prepare_statements(db, sql, &statements);
    if (rc != ER_OK)
    {
        ERRORPRINTF("sql3_prepare_statements returns [%d] sql [%s]", rc, sql);
        ret = rc;
    }

    if (ret == ER_OK  &&  parameters)
    {
        rc = sql3_bind_parameters(statements, parameters);
        if (rc != ER_OK)
        {
            ERRORPRINTF("sql3_bind_parameters returns [%d] sql [%s]", rc, sql);
            ret = rc;
        }
    }

    metadata_table *result = NULL;
    if (ret == ER_OK)
    {
        rc = sql3_execute_statements(db, statements, &result);
        if (rc != ER_OK)
        {
            ERRORPRINTF("sql3_execute_statements returns [%d] sql [%s]", rc, sql);
            ret = rc;
        }
    }

    // clean up
    if (statements)
    {
        sql3_finalize_statements(statements);
        statements = NULL;
    }

    // return result
    if (result_table)
    {
        *result_table = result;
        result = NULL;
    }
    metadata_table_free(result);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sql3_execute_statements	(	sqlite3 *	db,
		const GPtrArray *	statements,
		metadata_table **	result_table
	)			[static]

Parse sql string and compile into byte code.

---------------------------------------------------------------------------

Name : sql3_execute_statements

Parameters:

[in]	db	- sqlite database object
[in]	statements	- GPtrArray with compiled statements
[in]	result_table	- location to store metadata_table holding query results, or NULL when caller is not interested in query results
[out]	result_table	- metadata_table holding query results, or NULL when no results First row holds column names and cell values, other rows hold cell values only.

Returns:

ER_OK or error code

--------------------------------------------------------------------------

Definition at line 393 of file sqlite3_wrapper.c.

References ER_INVALID_PARAMETER, ER_OK, ERRORPRINTF, execute_single_statement(), LOGPRINTF, and metadata_table_free.

Referenced by sql3_execute_query().

{
    LOGPRINTF("entry");

    g_return_val_if_fail( db                       , ER_INVALID_PARAMETER);
    g_return_val_if_fail( statements               , ER_INVALID_PARAMETER);
    g_return_val_if_fail((statements->len > 0     ), ER_INVALID_PARAMETER);
    g_return_val_if_fail( result_table             , ER_INVALID_PARAMETER);
    g_return_val_if_fail((   result_table == NULL
                          || *result_table == NULL), ER_INVALID_PARAMETER);

    // execute each statement
    int ret = ER_OK;
    unsigned int stmt_idx;
    metadata_table *result = NULL;
    for ( stmt_idx = 0 ; stmt_idx < statements->len  &&  ret == ER_OK ; stmt_idx++ )
    {
        sqlite3_stmt *stmt = g_ptr_array_index(statements, stmt_idx);
        // NOTE: memleak on result if several loops?
        ret = execute_single_statement(stmt, &result);
        if (ret != ER_OK)
        {
            ERRORPRINTF( "execute_single_statement returns [%d] on stmt_idx [%d], sqlite error [%s]",
                         ret, stmt_idx, sqlite3_errmsg(db) );
        }
    }

    // unbind and reset all statements
    for (stmt_idx = 0 ; stmt_idx < statements->len ; stmt_idx++)
    {
        sqlite3_stmt *stmt = g_ptr_array_index(statements, stmt_idx);

        // unbind all parameters on this statement
        int n_parms = sqlite3_bind_parameter_count(stmt);
        int parm_idx;
        for (parm_idx = 0 ; parm_idx < n_parms ; parm_idx++)
        {
            sqlite3_bind_null(stmt, parm_idx + 1);
        }

        // reset statement
        sqlite3_reset(stmt);
    }

    // discard results on error
    if (ret != ER_OK)
    {
        metadata_table_free(result);
    }

    if (result_table)
    {
        *result_table = result;
        result = NULL;
    }
    metadata_table_free(result);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sql3_finalize_statements

(

GPtrArray *

statements

)

[static]

Release compiled sql statements.

---------------------------------------------------------------------------

Name : sql3_finalize_statements

Parameters:

[in]

statements

- GPtrArray with compiled statements

--------------------------------------------------------------------------

Definition at line 82 of file sqlite3_wrapper.c.

References LOGPRINTF.

Referenced by sql3_execute_query(), and sql3_prepare_statements().

{
    LOGPRINTF("entry");

    if (statements)
    {
        unsigned int i;
        for (i = 0 ; i < statements->len ; i++)
        {
            sqlite3_stmt *stmt = g_ptr_array_index(statements, i);
            sqlite3_finalize(stmt);
        }
        g_ptr_array_free(statements, TRUE);
    }
}

Here is the caller graph for this function:

static int sql3_prepare_statements	(	sqlite3 *	db,
		const char *	sql,
		GPtrArray **	statements
	)			[static]

Parse sql string and compile into byte code.

---------------------------------------------------------------------------

Name : sql3_prepare_statements

Parameters:

[in]	db	- sqlite database object
[in]	sql	- SQL statement(s) as text
[out]	statements	- GPtrArray with compiled statements, or NULL

Returns:

ER_OK or error code

--------------------------------------------------------------------------

Definition at line 112 of file sqlite3_wrapper.c.

References ER_INVALID_PARAMETER, ER_OK, ER_OUT_OF_MEMORY, ERMETADB_FAIL, ERRORPRINTF, LOGPRINTF, and sql3_finalize_statements().

Referenced by sql3_execute_query().

{
    int          ret = ER_OK;     // return code
    const char   *head = NULL;    // start of current sql statement
    const char   *tail = NULL;    // start of next sql statement, if any
    sqlite3_stmt *stmt = NULL;
    GPtrArray    *stmt_list = NULL;

    LOGPRINTF("entry: sql [%s]", sql);

    g_return_val_if_fail( db                  , ER_INVALID_PARAMETER);
    g_return_val_if_fail( sql                 , ER_INVALID_PARAMETER);
    g_return_val_if_fail((*sql != '\0'       ), ER_INVALID_PARAMETER);
    g_return_val_if_fail( statements          , ER_INVALID_PARAMETER);
    g_return_val_if_fail((*statements == NULL), ER_INVALID_PARAMETER);

    // parse sql string and store compiled statements
    gboolean done = FALSE;
    for ( done = FALSE, head = sql ; !done ; head = tail )
    {
        int rc = sqlite3_prepare_v2(db, head, -1, &stmt, &tail);
        if (rc != ER_OK)
        {
            ERRORPRINTF("sqlite error [%d] [%s] on prepare_v2 [%s]", rc, sqlite3_errmsg(db), head);
            ret  = ERMETADB_FAIL;
            done = TRUE;
        }
        else
        {
            if (stmt)
            {
                // statement compiled: store it
                if (stmt_list == NULL)
                {
                    stmt_list = g_ptr_array_new();
                    if (stmt_list == NULL)
                    {
                        ERRORPRINTF("cannot create GPtrArray");
                        ret  = ER_OUT_OF_MEMORY;
                        done = TRUE;
                    }
                }
                if (stmt_list)
                {
                    g_ptr_array_add(stmt_list, stmt);
                }
                stmt = NULL;
            }

            if (*tail == '\0')
            {
                // no more sql to process
                done = TRUE;
            }
        }
    }

    // discard compiled statements in case of error
    if (ret != ER_OK)
    {
        if (stmt_list)
        {
            sql3_finalize_statements(stmt_list);
            stmt_list = NULL;
        }
    }

    // return list of prepared statements
    *statements = stmt_list;
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int sql3_strcase_compare	(	void *	user_data,
		int	left_len,
		const void *	left_void,
		int	right_len,
		const void *	right_void
	)

Compare function to be used in custom collation sequence See documentation on sqlite3_create_collation() for details.

---------------------------------------------------------------------------

Name : sql3_strcase_cmp

--------------------------------------------------------------------------

Definition at line 706 of file sqlite3_wrapper.c.

References LOGPRINTF, and UNUSED.

Referenced by open_sqlite_database().

{
    UNUSED(user_data);
    int         ret = 0;
    const gchar *left  = (gchar*)left_void;
    const gchar *right = (gchar*)right_void;

    int len = MIN(left_len, right_len);
    if (len == 0)
    {
        // empty string sorts at end of list
        if (left_len == right_len)
        {
            ret = 0;
        }
        else if (left_len == 0)
        {
            ret = 1;
        }
        else
        {
            ret = -1;
        }
    }
    else
    {
        // non-empty string sorts case-insensitive
        ret = g_ascii_strncasecmp(left, right, len);
        if (ret == 0)
        {
            if (left_len < right_len)
            {
                ret = -1;
            }
            else
            {
                ret = 1;
            }
        }
    }

    LOGPRINTF("return [%d] left [%.*s] right [%.*s]", ret, left_len, left, right_len, right);
    return ret;
}

Here is the caller graph for this function:

---

Variable Documentation

const int BEGIN_MAX_RETRIES = 20 [static]

Definition at line 57 of file sqlite3_wrapper.c.

Referenced by begin_transaction().

const int BEGIN_RETRY_MS = 250 [static]

Definition at line 58 of file sqlite3_wrapper.c.

Referenced by begin_transaction(), and sql3_commit_or_rollback().

const int COMMIT_MAX_RETRIES = 30 [static]

Definition at line 61 of file sqlite3_wrapper.c.

Referenced by sql3_commit_or_rollback().

const int COMMIT_RETRY_MS = 100 [static]

Definition at line 62 of file sqlite3_wrapper.c.

const int STEP_MAX_RETRIES = 10 [static]

Definition at line 65 of file sqlite3_wrapper.c.

Referenced by execute_single_statement().

const int STEP_RETRY_MS = 100 [static]

Definition at line 66 of file sqlite3_wrapper.c.

Referenced by execute_single_statement().