Data Structures
struct	GncSqlBackend
struct	GncSqlStatement
struct	GncSqlConnection
struct	GncSqlRow
struct	GncSqlResult
struct	GncSqlObjectBackend
struct	GncSqlColumnInfo
struct	GncSqlColumnTableEntry
struct	GncSqlColumnTypeHandler
struct	write_objects_t
Modules
	Columns
Files
file	gnc-backend-sql.h
	load and save data to SQL
Defines
#define	gnc_sql_statement_dispose(STMT) (STMT)->dispose(STMT)
#define	gnc_sql_statement_to_sql(STMT) (STMT)->toSql(STMT)
#define	gnc_sql_statement_add_where_cond(STMT, TYPENAME, OBJ, COLDESC, VALUE) (STMT)->addWhereCond(STMT, TYPENAME, OBJ, COLDESC, VALUE)
#define	gnc_sql_connection_dispose(CONN) (CONN)->dispose(CONN)
#define	gnc_sql_connection_execute_select_statement(CONN, STMT) (CONN)->executeSelectStatement(CONN,STMT)
#define	gnc_sql_connection_execute_nonselect_statement(CONN, STMT) (CONN)->executeNonSelectStatement(CONN,STMT)
#define	gnc_sql_connection_create_statement_from_sql(CONN, SQL) (CONN)->createStatementFromSql(CONN,SQL)
#define	gnc_sql_connection_does_table_exist(CONN, NAME) (CONN)->doesTableExist(CONN,NAME)
#define	gnc_sql_connection_begin_transaction(CONN) (CONN)->beginTransaction(CONN)
#define	gnc_sql_connection_rollback_transaction(CONN) (CONN)->rollbackTransaction(CONN)
#define	gnc_sql_connection_commit_transaction(CONN) (CONN)->commitTransaction(CONN)
#define	gnc_sql_connection_create_table(CONN, NAME, COLLIST) (CONN)->createTable(CONN,NAME,COLLIST)
#define	gnc_sql_connection_create_index(CONN, INDEXNAME, TABLENAME, COLTABLE) (CONN)->createIndex(CONN,INDEXNAME,TABLENAME,COLTABLE)
#define	gnc_sql_connection_add_columns_to_table(CONN, TABLENAME, COLLIST) (CONN)->addColumnsToTable(CONN,TABLENAME,COLLIST)
#define	gnc_sql_connection_quote_string(CONN, STR) (CONN)->quoteString(CONN,STR)
#define	gnc_sql_row_get_value_at_col_name(ROW, N) (ROW)->getValueAtColName(ROW,N)
#define	gnc_sql_row_dispose(ROW) (ROW)->dispose(ROW)
#define	gnc_sql_result_get_num_rows(RESULT) (RESULT)->getNumRows(RESULT)
#define	gnc_sql_result_get_first_row(RESULT) (RESULT)->getFirstRow(RESULT)
#define	gnc_sql_result_get_next_row(RESULT) (RESULT)->getNextRow(RESULT)
#define	gnc_sql_result_dispose(RESULT) (RESULT)->dispose(RESULT)
#define	GNC_SQL_BACKEND "gnc:sql:1"
#define	GNC_SQL_BACKEND_VERSION 1
#define	CT_STRING "ct_string"
#define	CT_GUID "ct_guid"
#define	CT_INT "ct_int"
#define	CT_INT64 "ct_int64"
#define	CT_TIMESPEC "ct_timespec"
#define	CT_GDATE "ct_gdate"
#define	CT_NUMERIC "ct_numeric"
#define	CT_DOUBLE "ct_double"
#define	CT_BOOLEAN "ct_boolean"
#define	CT_ACCOUNTREF "ct_accountref"
#define	CT_BUDGETREF "ct_budgetref"
#define	CT_COMMODITYREF "ct_commodityref"
#define	CT_LOTREF "ct_lotref"
#define	CT_TXREF "ct_txref"
Typedefs
typedef struct GncSqlConnection	GncSqlConnection
typedef struct GncSqlBackend	GncSqlBackend
typedef struct GncSqlColumnTableEntry	GncSqlColumnTableEntry
typedef struct GncSqlStatement	GncSqlStatement
typedef struct GncSqlResult	GncSqlResult
typedef struct GncSqlRow	GncSqlRow
typedef void(*	GNC_SQL_LOAD_FN )(const GncSqlBackend be, GncSqlRow row, QofSetterFunc setter, gpointer pObject, const GncSqlColumnTableEntry *table)
typedef void(*	GNC_SQL_ADD_COL_INFO_TO_LIST_FN )(const GncSqlBackend be, const GncSqlColumnTableEntry table_row, GList **pList)
typedef void(*	GNC_SQL_ADD_COLNAME_TO_LIST_FN )(const GncSqlColumnTableEntry table_row, GList *pList)
typedef void(*	GNC_SQL_ADD_GVALUE_TO_SLIST_FN )(const GncSqlBackend be, QofIdTypeConst obj_name, const gpointer pObject, const GncSqlColumnTableEntry table_row, GSList **pList)
Enumerations
enum	GncSqlBasicColumnType { BCT_STRING, BCT_INT, BCT_INT64, BCT_DATE, BCT_DOUBLE, BCT_DATETIME }
enum	E_DB_OPERATION { OP_DB_INSERT, OP_DB_UPDATE, OP_DB_DELETE }
Functions
void	gnc_sql_init (GncSqlBackend *be)
void	gnc_sql_load (GncSqlBackend be, QofBook book, QofBackendLoadType loadType)
void	gnc_sql_sync_all (GncSqlBackend be, QofBook book)
void	gnc_sql_begin_edit (GncSqlBackend be, QofInstance inst)
void	gnc_sql_rollback_edit (GncSqlBackend qbe, QofInstance inst)
void	gnc_sql_commit_edit (GncSqlBackend qbe, QofInstance inst)
QofAccessFunc	gnc_sql_get_getter (QofIdTypeConst obj_name, const GncSqlColumnTableEntry *table_row)
void	gnc_sql_add_colname_to_list (const GncSqlColumnTableEntry table_row, GList *pList)
gboolean	gnc_sql_do_db_operation (GncSqlBackend be, E_DB_OPERATION op, const gchar table_name, QofIdTypeConst obj_name, gpointer pObject, const GncSqlColumnTableEntry *table)
GncSqlResult *	gnc_sql_execute_select_statement (GncSqlBackend be, GncSqlStatement statement)
GncSqlResult *	gnc_sql_execute_select_sql (GncSqlBackend be, const gchar sql)
gint	gnc_sql_execute_nonselect_sql (GncSqlBackend be, const gchar sql)
GncSqlStatement *	gnc_sql_create_statement_from_sql (GncSqlBackend be, const gchar sql)
void	gnc_sql_load_object (const GncSqlBackend be, GncSqlRow row, QofIdTypeConst obj_name, gpointer pObject, const GncSqlColumnTableEntry *table)
gboolean	gnc_sql_object_is_it_in_db (GncSqlBackend be, const gchar table_name, QofIdTypeConst obj_name, const gpointer pObject, const GncSqlColumnTableEntry *table)
gint	gnc_sql_get_table_version (const GncSqlBackend be, const gchar table_name)
gboolean	gnc_sql_set_table_version (GncSqlBackend be, const gchar table_name, gint version)
gboolean	gnc_sql_create_table (GncSqlBackend be, const gchar table_name, gint table_version, const GncSqlColumnTableEntry *col_table)
gboolean	gnc_sql_create_temp_table (const GncSqlBackend be, const gchar table_name, const GncSqlColumnTableEntry *col_table)
gboolean	gnc_sql_create_index (const GncSqlBackend be, const gchar index_name, const gchar table_name, const GncSqlColumnTableEntry col_table)
const GncGUID *	gnc_sql_load_guid (const GncSqlBackend be, GncSqlRow row)
const GncGUID *	gnc_sql_load_tx_guid (const GncSqlBackend be, GncSqlRow row)
GncSqlStatement *	gnc_sql_create_select_statement (GncSqlBackend be, const gchar table_name)
void	gnc_sql_register_col_type_handler (const gchar colType, const GncSqlColumnTypeHandler handler)
void	gnc_sql_add_gvalue_objectref_guid_to_slist (const GncSqlBackend be, QofIdTypeConst obj_name, const gpointer pObject, const GncSqlColumnTableEntry table_row, GSList **pList)
void	gnc_sql_add_objectref_guid_col_info_to_list (const GncSqlBackend be, const GncSqlColumnTableEntry table_row, GList **pList)
guint	gnc_sql_append_guid_list_to_sql (GString str, GList list, guint maxCount)
void	gnc_sql_add_subtable_colnames_to_list (const GncSqlColumnTableEntry table_row, const GncSqlColumnTableEntry subtable, GList **pList)
gchar *	gnc_sql_get_sql_value (const GncSqlConnection conn, const GValue value)
void	gnc_sql_init_version_info (GncSqlBackend *be)
void	gnc_sql_finalize_version_info (GncSqlBackend *be)
gboolean	gnc_sql_commit_standard_item (GncSqlBackend be, QofInstance inst, const gchar tableName, QofIdTypeConst obj_name, const GncSqlColumnTableEntry col_table)
gint64	gnc_sql_get_integer_value (const GValue *value)
gchar *	gnc_sql_convert_timespec_to_string (const GncSqlBackend *be, Timespec ts)
void	gnc_sql_upgrade_table (GncSqlBackend be, const gchar table_name, const GncSqlColumnTableEntry *col_table)
gboolean	gnc_sql_add_columns_to_table (GncSqlBackend be, const gchar table_name, const GncSqlColumnTableEntry *new_col_table)
void	gnc_sql_set_load_order (const gchar **load_order)
void	_retrieve_guid_ (gpointer pObject, gpointer pValue)
gpointer	gnc_sql_compile_query (QofBackend pBEnd, QofQuery pQuery)
void	gnc_sql_free_query (QofBackend *pBEnd, gpointer pQuery)
void	gnc_sql_run_query (QofBackend *pBEnd, gpointer pQuery)

Enumeration Type Documentation

enum GncSqlBasicColumnType

Basic column type

Definition at line 276 of file gnc-backend-sql.h.

{
    BCT_STRING,
    BCT_INT,
    BCT_INT64,
    BCT_DATE,
    BCT_DOUBLE,
    BCT_DATETIME
} GncSqlBasicColumnType;

Function Documentation

void gnc_sql_add_colname_to_list	(	const GncSqlColumnTableEntry *	table_row,
		GList **	pList
	)

Adds a column name to a list. If the column type spans multiple columns, all of the column names for the pieces are added.

Parameters:

table_row	DB table column
pList	List

Definition at line 1210 of file gnc-backend-sql.c.

{
    (*pList) = g_list_append( (*pList), g_strdup( table_row->col_name ) );
}

gboolean gnc_sql_add_columns_to_table	(	GncSqlBackend *	be,
		const gchar *	table_name,
		const GncSqlColumnTableEntry *	new_col_table
	)

Adds one or more columns to an existing table.

Parameters:

be	SQL backend
table_name	SQL table name
new_col_table	Column table for new columns

Returns:: TRUE if successful, FALSE if unsuccessful

Definition at line 3196 of file gnc-backend-sql.c.

{
    GList* col_info_list = NULL;
    gboolean ok = FALSE;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( new_col_table != NULL, FALSE );

    for ( ; new_col_table->col_name != NULL; new_col_table++ )
    {
        GncSqlColumnTypeHandler* pHandler;

        pHandler = get_handler( new_col_table );
        g_assert( pHandler != NULL );
        pHandler->add_col_info_to_list_fn( be, new_col_table, &col_info_list );
    }
    g_assert( col_info_list != NULL );
    ok = gnc_sql_connection_add_columns_to_table( be->conn, table_name, col_info_list );
    return ok;
}

void gnc_sql_add_gvalue_objectref_guid_to_slist	(	const GncSqlBackend *	be,
		QofIdTypeConst	obj_name,
		const gpointer	pObject,
		const GncSqlColumnTableEntry *	table_row,
		GSList **	pList
	)

Adds a GValue for an object reference GncGUID to the end of a GSList.

Parameters:

be	SQL backend struct
obj_name	QOF object type name
pObject	Object
table_row	DB table column description
pList	List

Definition at line 1854 of file gnc-backend-sql.c.

{
    QofAccessFunc getter;
    const GncGUID* guid = NULL;
    gchar guid_buf[GUID_ENCODING_LENGTH+1];
    QofInstance* inst = NULL;
    GValue* value;

    g_return_if_fail( be != NULL );
    g_return_if_fail( obj_name != NULL );
    g_return_if_fail( pObject != NULL );
    g_return_if_fail( table_row != NULL );

    value = g_new0( GValue, 1 );
    g_assert( value != NULL );
    if ( table_row->gobj_param_name != NULL )
    {
        g_object_get( pObject, table_row->gobj_param_name, &inst, NULL );
    }
    else
    {
        getter = gnc_sql_get_getter( obj_name, table_row );
        if ( getter != NULL )
        {
            inst = (*getter)( pObject, NULL );
        }
    }
    if ( inst != NULL )
    {
        guid = qof_instance_get_guid( inst );
    }
    (void)g_value_init( value, G_TYPE_STRING );
    if ( guid != NULL )
    {
        (void)guid_to_string_buff( guid, guid_buf );
        g_value_set_string( value, guid_buf );
    }

    (*pList) = g_slist_append( (*pList), value );
}

void gnc_sql_add_objectref_guid_col_info_to_list	(	const GncSqlBackend *	be,
		const GncSqlColumnTableEntry *	table_row,
		GList **	pList
	)

Adds a column info structure for an object reference GncGUID to the end of a GList.

Parameters:

be	SQL backend struct
table_row	DB table column description
pList	List

Definition at line 1897 of file gnc-backend-sql.c.

{
    add_guid_col_info_to_list( be, table_row, pList );
}

void gnc_sql_add_subtable_colnames_to_list	(	const GncSqlColumnTableEntry *	table_row,
		const GncSqlColumnTableEntry *	subtable,
		GList **	pList
	)

Appends column names for a subtable to the end of a GList.

Parameters:

table_row	Main DB column description
subtable	Sub-column description table
pList	List

Definition at line 1217 of file gnc-backend-sql.c.

{
    const GncSqlColumnTableEntry* subtable_row;
    gchar* buf;

    for ( subtable_row = subtable; subtable_row->col_name != NULL; subtable_row++ )
    {
        buf = g_strdup_printf( "%s_%s", table_row->col_name, subtable_row->col_name );
        (*pList) = g_list_append( (*pList), buf );
    }
}

guint gnc_sql_append_guid_list_to_sql	(	GString *	str,
		GList *	list,
		guint	maxCount
	)

Appends the ascii strings for a list of GUIDs to the end of an SQL string.

Parameters:

str	SQL string
list	List of GUIDs
maxCount	Max # of GUIDs to append

Returns:: Number of GUIDs appended

Definition at line 2619 of file gnc-backend-sql.c.

{
    gchar guid_buf[GUID_ENCODING_LENGTH+1];
    gboolean first_guid = TRUE;
    guint count;

    g_return_val_if_fail( sql != NULL, 0 );

    if ( list == NULL ) return 0;

    for ( count = 0; list != NULL && count < maxCount; list = list->next, count++ )
    {
        QofInstance* inst = QOF_INSTANCE(list->data);
        (void)guid_to_string_buff( qof_instance_get_guid( inst ), guid_buf );

        if ( !first_guid )
        {
            (void)g_string_append( sql, "," );
        }
        (void)g_string_append( sql, "'" );
        (void)g_string_append( sql, guid_buf );
        (void)g_string_append( sql, "'" );
        first_guid = FALSE;
    }

    return count;
}

void gnc_sql_begin_edit	(	GncSqlBackend *	be,
		QofInstance *	inst
	)

An object is about to be edited.

Parameters:

be	SQL backend
inst	Object being edited

Definition at line 568 of file gnc-backend-sql.c.

{
    g_return_if_fail( be != NULL );
    g_return_if_fail( inst != NULL );

    ENTER( " " );
    LEAVE( "" );
}

void gnc_sql_commit_edit	(	GncSqlBackend *	qbe,
		QofInstance *	inst
	)

Object editting is complete and the object should be saved.

Parameters:

qbe	SQL backend
inst	Object being edited

Definition at line 611 of file gnc-backend-sql.c.

{
    sql_backend be_data;
    gboolean is_dirty;
    gboolean is_destroying;
    gboolean is_infant;

    g_return_if_fail( be != NULL );
    g_return_if_fail( inst != NULL );

    if ( qof_book_is_readonly( be->book ) )
    {
        qof_backend_set_error( (QofBackend*)be, ERR_BACKEND_READONLY );
        (void)gnc_sql_connection_rollback_transaction( be->conn );
        return;
    }
    /* During initial load where objects are being created, don't commit
    anything, but do mark the object as clean. */
    if ( be->loading )
    {
        qof_instance_mark_clean( inst );
        return;
    }

    // The engine has a PriceDB object but it isn't in the database
    if ( strcmp( inst->e_type, "PriceDB" ) == 0 )
    {
        qof_instance_mark_clean( inst );
        qof_book_mark_session_saved( be->book );
        return;
    }

    ENTER( " " );

    is_dirty = qof_instance_get_dirty_flag( inst );
    is_destroying = qof_instance_get_destroying( inst );
    is_infant = qof_instance_get_infant( inst );

    DEBUG( "%s dirty = %d, do_free = %d, infant = %d\n",
    (inst->e_type ? inst->e_type : "(null)"),
    is_dirty, is_destroying, is_infant );

    if ( !is_dirty && !is_destroying )
    {
        LEAVE( "!dirty OR !destroying" );
        return;
    }

    if ( !gnc_sql_connection_begin_transaction( be->conn ) )
    {
        PERR( "gnc_sql_commit_edit(): begin_transaction failed\n" );
        LEAVE( "Rolled back - database transaction begin error" );
        return;
    }

    be_data.is_known = FALSE;
    be_data.be = be;
    be_data.inst = inst;
    be_data.is_ok = TRUE;

    qof_object_foreach_backend( GNC_SQL_BACKEND, commit_cb, &be_data );

    if ( !be_data.is_known )
    {
        PERR( "gnc_sql_commit_edit(): Unknown object type '%s'\n", inst->e_type );
        (void)gnc_sql_connection_rollback_transaction( be->conn );

        // Don't let unknown items still mark the book as being dirty
        qof_book_mark_session_saved( be->book );
        qof_instance_mark_clean(inst);
        LEAVE( "Rolled back - unknown object type" );
        return;
    }
    if ( !be_data.is_ok )
    {
        // Error - roll it back
        (void)gnc_sql_connection_rollback_transaction( be->conn );

        // This *should* leave things marked dirty
        LEAVE( "Rolled back - database error" );
        return;
    }

    (void)gnc_sql_connection_commit_transaction( be->conn );

    qof_book_mark_session_saved( be->book );
    qof_instance_mark_clean(inst);

    LEAVE( "" );
}

gboolean gnc_sql_commit_standard_item	(	GncSqlBackend *	be,
		QofInstance *	inst,
		const gchar *	tableName,
		QofIdTypeConst	obj_name,
		const GncSqlColumnTableEntry *	col_table
	)

Commits a "standard" item to the database. In most cases, a commit of one object vs another differs only in the table name and column table.

Parameters:

be	SQL backend
inst	Instance
tableName	SQL table name
obj_name	QOF object type name
col_table	Column table

Returns:: TRUE if successful, FALSE if not

Definition at line 3034 of file gnc-backend-sql.c.

{
    const GncGUID* guid;
    gboolean is_infant;
    gint op;
    gboolean is_ok;

    is_infant = qof_instance_get_infant( inst );
    if ( qof_instance_get_destroying( inst ) )
    {
        op = OP_DB_DELETE;
    }
    else if ( be->is_pristine_db || is_infant )
    {
        op = OP_DB_INSERT;
    }
    else
    {
        op = OP_DB_UPDATE;
    }
    is_ok = gnc_sql_do_db_operation( be, op, tableName, obj_name, inst, col_table );

    if ( is_ok )
    {
        // Now, commit any slots
        guid = qof_instance_get_guid( inst );
        if ( !qof_instance_get_destroying(inst) )
        {
            is_ok = gnc_sql_slots_save( be, guid, is_infant, qof_instance_get_slots( inst ) );
        }
        else
        {
            is_ok = gnc_sql_slots_delete( be, guid );
        }
    }

    return is_ok;
}

gchar* gnc_sql_convert_timespec_to_string	(	const GncSqlBackend *	be,
		Timespec	ts
	)

Converts a Timespec value to a string value for the database.

Parameters:

be	SQL backend
ts	Timespec to be converted

Returns:: String representation of the Timespec

Definition at line 1912 of file gnc-backend-sql.c.

{
    time_t time;
    struct tm* tm;
    gint year;
    gchar* datebuf;

    time = timespecToTime_t( ts );
    tm = gmtime( &time );

    if ( tm->tm_year < 60 ) year = tm->tm_year + 2000;
    else year = tm->tm_year + 1900;

    datebuf = g_strdup_printf( be->timespec_format,
                               year, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec );
    return datebuf;
}

gboolean gnc_sql_create_index	(	const GncSqlBackend *	be,
		const gchar *	index_name,
		const gchar *	table_name,
		const GncSqlColumnTableEntry *	col_table
	)

Creates an index in the database

Parameters:

be	SQL backend struct
index_name	Index name
table_name	Table name
col_table	Columns that the index should index

Returns:: TRUE if successful, FALSE if unsuccessful

Definition at line 3132 of file gnc-backend-sql.c.

{
    gboolean ok;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( index_name != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( col_table != NULL, FALSE );

    ok = gnc_sql_connection_create_index( be->conn, index_name, table_name,
                                          col_table );
    return ok;
}

GncSqlStatement* gnc_sql_create_select_statement	(	GncSqlBackend *	be,
		const gchar *	table_name
	)

Creates a basic SELECT statement for a table.

Parameters:

be	SQL backend struct
table_name	Table name

Returns:: Statement

Definition at line 2485 of file gnc-backend-sql.c.

{
    gchar* sql;
    GncSqlStatement* stmt;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( table_name != NULL, NULL );

    sql = g_strdup_printf( "SELECT * FROM %s", table_name );
    stmt = gnc_sql_create_statement_from_sql( be, sql );
    g_free( sql );
    return stmt;
}

GncSqlStatement* gnc_sql_create_statement_from_sql	(	GncSqlBackend *	be,
		const gchar *	sql
	)

Creates a statement from an SQL char string.

Parameters:

be	SQL backend struct
sql	SQL char string

Returns:: Statement

Definition at line 2538 of file gnc-backend-sql.c.

{
    GncSqlStatement* stmt;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( sql != NULL, NULL );

    stmt = gnc_sql_connection_create_statement_from_sql( be->conn, sql );
    if ( stmt == NULL )
    {
        PERR( "SQL error: %s\n", sql );
        qof_backend_set_error( &be->be, ERR_BACKEND_SERVER_ERR );
    }

    return stmt;
}

gboolean gnc_sql_create_table	(	GncSqlBackend *	be,
		const gchar *	table_name,
		gint	table_version,
		const GncSqlColumnTableEntry *	col_table
	)

Creates a table in the database

Parameters:

be	SQL backend struct
table_name	Table name
table_version	Table version
col_table	DB table description

Returns:: TRUE if successful, FALSE if unsuccessful

Definition at line 3101 of file gnc-backend-sql.c.

{
    gboolean ok;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( col_table != NULL, FALSE );

    DEBUG( "Creating %s table\n", table_name );

    ok = do_create_table( be, table_name, col_table );
    if ( ok )
    {
        ok = gnc_sql_set_table_version( be, table_name, table_version );
    }
    return ok;
}

gboolean gnc_sql_create_temp_table	(	const GncSqlBackend *	be,
		const gchar *	table_name,
		const GncSqlColumnTableEntry *	col_table
	)

Creates a temporary table in the database. A temporary table does not have a version number added to the versions table.

Parameters:

be	SQL backend struct
table_name	Table name
col_table	DB table description

Returns:: TRUE if successful, FALSE if unsuccessful

Definition at line 3121 of file gnc-backend-sql.c.

{
    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( col_table != NULL, FALSE );

    return do_create_table( be, table_name, col_table );
}

gboolean gnc_sql_do_db_operation	(	GncSqlBackend *	be,
		E_DB_OPERATION	op,
		const gchar *	table_name,
		QofIdTypeConst	obj_name,
		gpointer	pObject,
		const GncSqlColumnTableEntry *	table
	)

Performs an operation on the database.

Parameters:

be	SQL backend struct
op	Operation type
table_name	SQL table name
obj_name	QOF object type name
pObject	Gnucash object
table	DB table description

Returns:: TRUE if successful, FALSE if not

Definition at line 2688 of file gnc-backend-sql.c.

{
    GncSqlStatement* stmt = NULL;
    gboolean ok = FALSE;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( obj_name != NULL, FALSE );
    g_return_val_if_fail( pObject != NULL, FALSE );
    g_return_val_if_fail( table != NULL, FALSE );

    if ( op == OP_DB_INSERT )
    {
        stmt = build_insert_statement( be, table_name, obj_name, pObject, table );
    }
    else if ( op == OP_DB_UPDATE )
    {
        stmt = build_update_statement( be, table_name, obj_name, pObject, table );
    }
    else if ( op == OP_DB_DELETE )
    {
        stmt = build_delete_statement( be, table_name, obj_name, pObject, table );
    }
    else
    {
        g_assert( FALSE );
    }
    if ( stmt != NULL )
    {
        gint result;

        result = gnc_sql_connection_execute_nonselect_statement( be->conn, stmt );
        if ( result == -1 )
        {
            PERR( "SQL error: %s\n", gnc_sql_statement_to_sql( stmt ) );
            qof_backend_set_error( &be->be, ERR_BACKEND_SERVER_ERR );
        }
        else
        {
            ok = TRUE;
        }
        gnc_sql_statement_dispose( stmt );
    }

    return ok;
}

gint gnc_sql_execute_nonselect_sql	(	GncSqlBackend *	be,
		const gchar *	sql
	)

Executes an SQL non-SELECT statement from an SQL char string.

Parameters:

be	SQL backend struct
sql	SQL non-SELECT string

Returns:: Number of rows affected, or -1 if an error has occured

Definition at line 2581 of file gnc-backend-sql.c.

{
    GncSqlStatement* stmt;
    gint result;

    g_return_val_if_fail( be != NULL, 0 );
    g_return_val_if_fail( sql != NULL, 0 );

    stmt = gnc_sql_create_statement_from_sql( be, sql );
    if ( stmt == NULL )
    {
        return -1;
    }
    result = gnc_sql_connection_execute_nonselect_statement( be->conn, stmt );
    gnc_sql_statement_dispose( stmt );
    return result;
}

GncSqlResult* gnc_sql_execute_select_sql	(	GncSqlBackend *	be,
		const gchar *	sql
	)

Executes an SQL SELECT statement from an SQL char string and returns the result rows. If an error occurs, an entry is added to the log, an error status is returned to qof and NULL is returned.

Parameters:

be	SQL backend struct
sql	SQL SELECT string

Returns:: Results, or NULL if an error has occured

Definition at line 2556 of file gnc-backend-sql.c.

{
    GncSqlStatement* stmt;
    GncSqlResult* result = NULL;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( sql != NULL, NULL );

    stmt = gnc_sql_create_statement_from_sql( be, sql );
    if ( stmt == NULL )
    {
        return NULL;
    }
    result = gnc_sql_connection_execute_select_statement( be->conn, stmt );
    gnc_sql_statement_dispose( stmt );
    if ( result == NULL )
    {
        PERR( "SQL error: %s\n", sql );
        qof_backend_set_error( &be->be, ERR_BACKEND_SERVER_ERR );
    }

    return result;
}

GncSqlResult* gnc_sql_execute_select_statement	(	GncSqlBackend *	be,
		GncSqlStatement *	statement
	)

Executes an SQL SELECT statement and returns the result rows. If an error occurs, an entry is added to the log, an error status is returned to qof and NULL is returned.

Parameters:

be	SQL backend struct
statement	Statement

Returns:: Results, or NULL if an error has occured

Definition at line 2520 of file gnc-backend-sql.c.

{
    GncSqlResult* result;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( stmt != NULL, NULL );

    result = gnc_sql_connection_execute_select_statement( be->conn, stmt );
    if ( result == NULL )
    {
        PERR( "SQL error: %s\n", gnc_sql_statement_to_sql( stmt ) );
        qof_backend_set_error( &be->be, ERR_BACKEND_SERVER_ERR );
    }

    return result;
}

void gnc_sql_finalize_version_info ( GncSqlBackend * be )

Finalizes DB table version information.

Parameters:

be	SQL backend struct

Finalizes the version table info by destroying the hash table.

Parameters:

be	Backend struct

Definition at line 3319 of file gnc-backend-sql.c.

{
    g_return_if_fail( be != NULL );

    if ( be->versions != NULL )
    {
        g_hash_table_destroy( be->versions );
        be->versions = NULL;
    }
}

QofAccessFunc gnc_sql_get_getter	(	QofIdTypeConst	obj_name,
		const GncSqlColumnTableEntry *	table_row
	)

Returns the QOF access function for a column.

Parameters:

obj_name	QOF object type name
table_row	DB table column

Returns:: Access function

Definition at line 1184 of file gnc-backend-sql.c.

{
    QofAccessFunc getter;

    g_return_val_if_fail( obj_name != NULL, NULL );
    g_return_val_if_fail( table_row != NULL, NULL );

    if ( (table_row->flags & COL_AUTOINC) != 0 )
    {
        getter = get_autoinc_id;
    }
    else if ( table_row->qof_param_name != NULL )
    {
        getter = qof_class_get_parameter_getter( obj_name,
        table_row->qof_param_name );
    }
    else
    {
        getter = table_row->getter;
    }

    return getter;
}

gint64 gnc_sql_get_integer_value ( const GValue * value )

Gets an integer value (of any size) from a GValue.

Parameters:

value Source value

Returns:: Integer value

Definition at line 1129 of file gnc-backend-sql.c.

{
    g_return_val_if_fail( value != NULL, 0 );

    if ( G_VALUE_HOLDS_INT(value) )
    {
        return (gint64)g_value_get_int( value );
    }
    else if ( G_VALUE_HOLDS_UINT(value) )
    {
        return (gint64)g_value_get_uint( value );
    }
    else if ( G_VALUE_HOLDS_LONG(value) )
    {
        return (gint64)g_value_get_long( value );
    }
    else if ( G_VALUE_HOLDS_ULONG(value) )
    {
        return (gint64)g_value_get_ulong( value );
    }
    else if ( G_VALUE_HOLDS_INT64(value) )
    {
        return g_value_get_int64( value );
    }
    else if ( G_VALUE_HOLDS_UINT64(value) )
    {
        return (gint64)g_value_get_uint64( value );
    }
    else if ( G_VALUE_HOLDS_STRING( value ) )
    {
        return g_ascii_strtoll( g_value_get_string( value ), NULL, 10 );
    }
    else
    {
        PWARN( "Unknown type: %s", G_VALUE_TYPE_NAME( value ) );
    }

    return 0;
}

gchar* gnc_sql_get_sql_value	(	const GncSqlConnection *	conn,
		const GValue *	value
	)

Returns a string corresponding to the SQL representation of a GValue. The caller must free the string.

Parameters:

conn	SQL connection
value	Value to be converted

Returns:: String

Definition at line 2763 of file gnc-backend-sql.c.

{
    if ( value != NULL && G_IS_VALUE( value ) )
    {
        GType type = G_VALUE_TYPE(value);

        if ( G_VALUE_HOLDS_STRING(value) )
        {
            if ( g_value_get_string( value ) != NULL )
            {
                gchar* before_str;
                gchar* after_str;
                before_str = g_value_dup_string( value );
                after_str = gnc_sql_connection_quote_string( conn, before_str );
                g_free( before_str );
                return after_str;
            }
            else
            {
                return g_strdup( "NULL" );
            }
        }
        else if ( type == G_TYPE_INT64 )
        {
            return g_strdup_printf( "%" G_GINT64_FORMAT, g_value_get_int64( value ) );

        }
        else if ( type == G_TYPE_INT )
        {
            return g_strdup_printf( "%d", g_value_get_int( value ) );

        }
        else if ( type == G_TYPE_DOUBLE )
        {
            gchar doublestr[G_ASCII_DTOSTR_BUF_SIZE];
            g_ascii_dtostr( doublestr, sizeof(doublestr),
                            g_value_get_double( value ));
            return g_strdup( doublestr );

        }
        else if ( g_value_type_transformable( type, G_TYPE_STRING ) )
        {
            GValue* string;
            gchar* str;

            string = g_new0( GValue, 1 );
            g_assert( string != NULL );
            (void)g_value_init( string, G_TYPE_STRING );
            (void)g_value_transform( value, string );
            str = g_value_dup_string( string );
            g_value_unset( string );
            g_free( string );
            PWARN( "using g_value_transform(), gtype = '%s'\n", g_type_name( type ) );
            return str;
        }
        else
        {
            PWARN( "not transformable, gtype = '%s'\n", g_type_name( type ) );
            return g_strdup( "$$$" );
        }
    }
    else
    {
        PWARN( "value is NULL or not G_IS_VALUE()\n" );
        return g_strdup( "" );
    }
}

gint gnc_sql_get_table_version	(	const GncSqlBackend *	be,
		const gchar *	table_name
	)

Returns the version number for a DB table.

Parameters:

be	SQL backend struct
table_name	Table name

Returns:: Version number, or 0 if the table does not exist

Definition at line 3149 of file gnc-backend-sql.c.

{
    g_return_val_if_fail( be != NULL, 0 );
    g_return_val_if_fail( table_name != NULL, 0 );

    /* If the db is pristine because it's being saved, the table does not exist. */
    if ( be->is_pristine_db )
    {
        return 0;
    }

    return GPOINTER_TO_INT(g_hash_table_lookup( be->versions, table_name ));
}

void gnc_sql_init ( GncSqlBackend * be )

Initialize the SQL backend.

Parameters:

be	SQL backend

Definition at line 140 of file gnc-backend-sql.c.

{
    static gboolean initialized = FALSE;

    if ( !initialized )
    {
        register_standard_col_type_handlers();
        gnc_sql_init_object_handlers();
        initialized = TRUE;
    }
}

void gnc_sql_init_version_info ( GncSqlBackend * be )

Initializes DB table version information.

Parameters:

be	SQL backend struct

Sees if the version table exists, and if it does, loads the info into the version hash table. Otherwise, it creates an empty version table.

Parameters:

be	Backend struct

Definition at line 3241 of file gnc-backend-sql.c.

{
    g_return_if_fail( be != NULL );

    if ( be->versions != NULL )
    {
        g_hash_table_destroy( be->versions );
    }
    be->versions = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, NULL );

    if ( gnc_sql_connection_does_table_exist( be->conn, VERSION_TABLE_NAME ) )
    {
        GncSqlResult* result;
        gchar* sql;

        sql = g_strdup_printf( "SELECT * FROM %s", VERSION_TABLE_NAME );
        result = gnc_sql_execute_select_sql( be, sql );
        g_free( sql );
        if ( result != NULL )
        {
            const GValue* name;
            const GValue* version;
            GncSqlRow* row;

            row = gnc_sql_result_get_first_row( result );
            while ( row != NULL )
            {
                name = gnc_sql_row_get_value_at_col_name( row, TABLE_COL_NAME );
                version = gnc_sql_row_get_value_at_col_name( row, VERSION_COL_NAME );
                g_hash_table_insert( be->versions,
                                     g_strdup( g_value_get_string( name ) ),
                                     GINT_TO_POINTER((gint)g_value_get_int64( version )) );
                row = gnc_sql_result_get_next_row( result );
            }
            gnc_sql_result_dispose( result );
        }
    }
    else
    {
        gboolean ok;

        ok = do_create_table( be, VERSION_TABLE_NAME, version_table );
    }
}

void gnc_sql_load	(	GncSqlBackend *	be,
		QofBook *	book,
		QofBackendLoadType	loadType
	)

Load the contents of an SQL database into a book.

Parameters:

be	SQL backend
book	Book to be loaded

Definition at line 217 of file gnc-backend-sql.c.

{
    GncSqlObjectBackend* pData;
    gint i;
    Account* root;

    g_return_if_fail( be != NULL );
    g_return_if_fail( book != NULL );

    ENTER( "be=%p, book=%p", be, book );

    be->loading = TRUE;

    if ( loadType == LOAD_TYPE_INITIAL_LOAD )
    {
        g_assert( be->book == NULL );
        be->book = book;

        /* Load any initial stuff. Some of this needs to happen in a certain order */
        for ( i = 0; fixed_load_order[i] != NULL; i++ )
        {
            pData = qof_object_lookup_backend( fixed_load_order[i], GNC_SQL_BACKEND );
            if ( pData->initial_load != NULL )
            {
                update_progress( be );
                (pData->initial_load)( be );
            }
        }
        if ( other_load_order != NULL )
        {
            for ( i = 0; other_load_order[i] != NULL; i++ )
            {
                pData = qof_object_lookup_backend( other_load_order[i], GNC_SQL_BACKEND );
                if ( pData->initial_load != NULL )
                {
                    update_progress( be );
                    (pData->initial_load)( be );
                }
            }
        }

        root = gnc_book_get_root_account( book );
        gnc_account_foreach_descendant( root, (AccountCb)xaccAccountBeginEdit, NULL );

        qof_object_foreach_backend( GNC_SQL_BACKEND, initial_load_cb, be );

        gnc_account_foreach_descendant( root, (AccountCb)xaccAccountCommitEdit, NULL );
    }
    else if ( loadType == LOAD_TYPE_LOAD_ALL )
    {
        // Load all transactions
        gnc_sql_transaction_load_all_tx( be );
    }

    be->loading = FALSE;

    /* Mark the sessoion as clean -- though it should never be marked
     * dirty with this backend
     */
    qof_book_mark_session_saved( book );
    finish_progress( be );

    LEAVE( "" );
}

const GncGUID* gnc_sql_load_guid	(	const GncSqlBackend *	be,
		GncSqlRow *	row
	)

Loads the object guid from a database row. The table must have a column named "guid" with type CT_GUID.

Parameters:

be	SQL backend struct
row	Database row

Returns:: GncGUID

Definition at line 2412 of file gnc-backend-sql.c.

{
    static GncGUID guid;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( row != NULL, NULL );

    gnc_sql_load_object( be, row, NULL, &guid, guid_table );

    return &guid;
}

void gnc_sql_load_object	(	const GncSqlBackend *	be,
		GncSqlRow *	row,
		QofIdTypeConst	obj_name,
		gpointer	pObject,
		const GncSqlColumnTableEntry *	table
	)

Loads a Gnucash object from the database.

Parameters:

be	SQL backend struct
row	DB result row
obj_name	QOF object type name
pObject	Object to be loaded
table	DB table description

Definition at line 2448 of file gnc-backend-sql.c.

{
    QofSetterFunc setter;
    GncSqlColumnTypeHandler* pHandler;
    const GncSqlColumnTableEntry* table_row;

    g_return_if_fail( be != NULL );
    g_return_if_fail( row != NULL );
    g_return_if_fail( pObject != NULL );
    g_return_if_fail( table != NULL );

    for ( table_row = table; table_row->col_name != NULL; table_row++ )
    {
        if ( (table_row->flags & COL_AUTOINC) != 0 )
        {
            setter = set_autoinc_id;
        }
        else if ( table_row->qof_param_name != NULL )
        {
            g_assert( obj_name != NULL );
            setter = qof_class_get_parameter_setter( obj_name,
                     table_row->qof_param_name );
        }
        else
        {
            setter = table_row->setter;
        }
        pHandler = get_handler( table_row );
        g_assert( pHandler != NULL );
        pHandler->load_fn( be, row, setter, pObject, table_row );
    }
}

const GncGUID* gnc_sql_load_tx_guid	(	const GncSqlBackend *	be,
		GncSqlRow *	row
	)

Loads the transaction guid from a database row. The table must have a column named "tx_guid" with type CT_GUID.

Parameters:

be	SQL backend struct
row	Database row

Returns:: GncGUID

Definition at line 2435 of file gnc-backend-sql.c.

{
    static GncGUID guid;

    g_return_val_if_fail( be != NULL, NULL );
    g_return_val_if_fail( row != NULL, NULL );

    gnc_sql_load_object( be, row, NULL, &guid, tx_guid_table );

    return &guid;
}

gboolean gnc_sql_object_is_it_in_db	(	GncSqlBackend *	be,
		const gchar *	table_name,
		QofIdTypeConst	obj_name,
		const gpointer	pObject,
		const GncSqlColumnTableEntry *	table
	)

Checks whether an object is in the database or not.

Parameters:

be	SQL backend struct
table_name	DB table name
obj_name	QOF object type name
pObject	Object to be checked
table	DB table description

Returns:: TRUE if the object is in the database, FALSE otherwise

Definition at line 2649 of file gnc-backend-sql.c.

{
    GncSqlStatement* sqlStmt;
    guint count;
    GncSqlColumnTypeHandler* pHandler;
    GSList* list = NULL;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( obj_name != NULL, FALSE );
    g_return_val_if_fail( pObject != NULL, FALSE );
    g_return_val_if_fail( table != NULL, FALSE );

    /* SELECT * FROM */
    sqlStmt = create_single_col_select_statement( be, table_name, table );
    g_assert( sqlStmt != NULL );

    /* WHERE */
    pHandler = get_handler( table );
    g_assert( pHandler != NULL );
    pHandler->add_gvalue_to_slist_fn( be, obj_name, pObject, table, &list );
    g_assert( list != NULL );
    gnc_sql_statement_add_where_cond( sqlStmt, obj_name, pObject, &table[0], (GValue*)(list->data) );

    count = execute_statement_get_count( be, sqlStmt );
    gnc_sql_statement_dispose( sqlStmt );
    if ( count == 0 )
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

void gnc_sql_register_col_type_handler	(	const gchar *	colType,
		const GncSqlColumnTypeHandler *	handler
	)

Registers a column handler for a new column type.

Parameters:

colType	Column type
handler	Column handler

Definition at line 2338 of file gnc-backend-sql.c.

{
    g_return_if_fail( colType != NULL );
    g_return_if_fail( handler != NULL );

    if ( g_columnTypeHash == NULL )
    {
        g_columnTypeHash = g_hash_table_new( g_str_hash, g_str_equal );
        g_assert( g_columnTypeHash != NULL );
    }

    DEBUG( "Col type %s registered\n", colType );
    g_hash_table_insert( g_columnTypeHash, (gpointer)colType, (gpointer)handler );
}

void gnc_sql_rollback_edit	(	GncSqlBackend *	qbe,
		QofInstance *	inst
	)

Object editing has been cancelled.

Parameters:

qbe	SQL backend
inst	Object being edited

Definition at line 578 of file gnc-backend-sql.c.

{
    g_return_if_fail( be != NULL );
    g_return_if_fail( inst != NULL );

    ENTER( " " );
    LEAVE( "" );
}

void gnc_sql_set_load_order ( const gchar ** load_order )

Specifies the load order for a set of objects. When loading from a database, the objects will be loaded in this order, so that when later objects have references to objects, those objects will already have been loaded.

Parameters:

load_order NULL-terminated array of object type ID strings

Definition at line 180 of file gnc-backend-sql.c.

{
    other_load_order = load_order;
}

gboolean gnc_sql_set_table_version	(	GncSqlBackend *	be,
		const gchar *	table_name,
		gint	version
	)

Registers the version for a table. Registering involves updating the db version table and also the hash table.

Parameters:

be	Backend struct
table_name	Table name
version	Version number

Returns:: TRUE if successful, FALSE if unsuccessful

Definition at line 3340 of file gnc-backend-sql.c.

{
    gchar* sql;
    gint cur_version;
    gint status;

    g_return_val_if_fail( be != NULL, FALSE );
    g_return_val_if_fail( table_name != NULL, FALSE );
    g_return_val_if_fail( version > 0, FALSE );

    cur_version = gnc_sql_get_table_version( be, table_name );
    if ( cur_version != version )
    {
        if ( cur_version == 0 )
        {
            sql = g_strdup_printf( "INSERT INTO %s VALUES('%s',%d)", VERSION_TABLE_NAME,
                                   table_name, version );
        }
        else
        {
            sql = g_strdup_printf( "UPDATE %s SET %s=%d WHERE %s='%s'", VERSION_TABLE_NAME,
                                   VERSION_COL_NAME, version,
                                   TABLE_COL_NAME, table_name );
        }
        status = gnc_sql_execute_nonselect_sql( be, sql );
        if ( status == -1 )
        {
            PERR( "SQL error: %s\n", sql );
            qof_backend_set_error( &be->be, ERR_BACKEND_SERVER_ERR );
        }
        g_free( sql );
    }

    g_hash_table_insert( be->versions, g_strdup( table_name ), GINT_TO_POINTER(version) );

    return TRUE;
}

void gnc_sql_sync_all	(	GncSqlBackend *	be,
		QofBook *	book
	)

Save the contents of a book to an SQL database.

Parameters:

be	SQL backend
book	Book to be saved

Definition at line 490 of file gnc-backend-sql.c.

{
    gboolean is_ok;

    g_return_if_fail( be != NULL );
    g_return_if_fail( book != NULL );

    ENTER( "book=%p, be->book=%p", book, be->book );
    update_progress( be );
    (void)reset_version_info( be );
    gnc_sql_set_table_version( be, "Gnucash", gnc_get_long_version() );
    gnc_sql_set_table_version( be, "Gnucash-Resave", GNUCASH_RESAVE_VERSION );

    /* Create new tables */
    be->is_pristine_db = TRUE;
    qof_object_foreach_backend( GNC_SQL_BACKEND, create_tables_cb, be );

    /* Save all contents */
    be->book = book;
    be->obj_total = 0;
    be->obj_total += 1 + gnc_account_n_descendants( gnc_book_get_root_account( book ) );
    be->obj_total += gnc_book_count_transactions( book );
    be->operations_done = 0;

    is_ok = gnc_sql_connection_begin_transaction( be->conn );

    // FIXME: should write the set of commodities that are used
    //write_commodities( be, book );
    if ( is_ok )
    {
        is_ok = gnc_sql_save_book( be, QOF_INSTANCE(book) );
    }
    if ( is_ok )
    {
        is_ok = write_accounts( be );
    }
    if ( is_ok )
    {
        is_ok = write_transactions( be );
    }
    if ( is_ok )
    {
        is_ok = write_template_transactions( be );
    }
    if ( is_ok )
    {
        is_ok = write_schedXactions( be );
    }
    if ( is_ok )
    {
        qof_object_foreach_backend( GNC_SQL_BACKEND, write_cb, be );
    }
    if ( is_ok )
    {
        is_ok = gnc_sql_connection_commit_transaction( be->conn );
    }
    if ( is_ok )
    {
        be->is_pristine_db = FALSE;

        /* Mark the session as clean -- though it shouldn't ever get
         * marked dirty with this backend
         */
        qof_book_mark_session_saved( book );
    }
    else
    {
        qof_backend_set_error( (QofBackend*)be, ERR_BACKEND_SERVER_ERR );
        is_ok = gnc_sql_connection_rollback_transaction( be->conn );
    }
    finish_progress( be );
    LEAVE( "book=%p", book );
}

void gnc_sql_upgrade_table	(	GncSqlBackend *	be,
		const gchar *	table_name,
		const GncSqlColumnTableEntry *	col_table
	)

Upgrades a table to a new structure. The upgrade is done by creating a new table with the new structure, SELECTing the old data into the new table, deleting the old table, then renaming the new table. Therefore, this will only work if the new table structure is similar enough to the old table that the SELECT will work.

Parameters:

be	SQL backend
table_name	SQL table name
col_table	Column table

Definition at line 3166 of file gnc-backend-sql.c.

{
    gchar* sql;
    gchar* temp_table_name;

    g_return_if_fail( be != NULL );
    g_return_if_fail( table_name != NULL );
    g_return_if_fail( col_table != NULL );

    DEBUG( "Upgrading %s table\n", table_name );

    temp_table_name = g_strdup_printf( "%s_new", table_name );
    (void)gnc_sql_create_temp_table( be, temp_table_name, col_table );
    sql = g_strdup_printf( "INSERT INTO %s SELECT * FROM %s",
                           temp_table_name, table_name );
    (void)gnc_sql_execute_nonselect_sql( be, sql );
    g_free( sql );

    sql = g_strdup_printf( "DROP TABLE %s", table_name );
    (void)gnc_sql_execute_nonselect_sql( be, sql );
    g_free( sql );

    sql = g_strdup_printf( "ALTER TABLE %s RENAME TO %s", temp_table_name, table_name );
    (void)gnc_sql_execute_nonselect_sql( be, sql );
    g_free( sql );
    g_free( temp_table_name );
}

Data Structures

Modules

Files

Defines

Typedefs

Enumerations

Functions

Enumeration Type Documentation

Function Documentation