Modules
	Columns

Files
file	gnc-backend-sql.h
	load and save data to SQL

Data Structures
struct	GncSqlBackend

struct	GncSqlStatement

struct	GncSqlConnection

struct	GncSqlRow

struct	GncSqlResult

struct	GncSqlObjectBackend

struct	GncSqlColumnInfo

struct	GncSqlColumnTableEntry

struct	GncSqlColumnTypeHandler

struct	write_objects_t

Macros
#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_push_commodity_for_postload_processing (GncSqlBackend be, gpointer comm)

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)

Detailed Description

Enumeration Type Documentation

enum GncSqlBasicColumnType

Basic column type

Definition at line 286 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 1166 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 3206 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 1825 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 1868 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 1173 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 2629 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 526 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 569 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 3044 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 1883 of file gnc-backend-sql.c.

 {
     time64 time;
     struct tm* tm;
     gint year;
     gchar* datebuf;
 
     time = timespecToTime64( ts );
     tm = gnc_gmtime( &time );
 
     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 );
     gnc_tm_free (tm);
     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 3142 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 2495 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 2548 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 3111 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 3131 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 2698 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 2591 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 2566 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 2530 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 3333 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 1140 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 1085 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 2773 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 3159 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 137 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 3251 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
     {
         do_create_table( be, VERSION_TABLE_NAME, version_table );
         gnc_sql_set_table_version( be, "Gnucash",
                                    gnc_prefs_get_long_version() );
         gnc_sql_set_table_version( be, "Gnucash-Resave",
                                    GNUCASH_RESAVE_VERSION );
     }
 }

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 228 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;
     g_list_free_full (post_load_commodities, commit_commodity);
     post_load_commodities = NULL;
 
     /* 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 2422 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 2458 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 2445 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 2659 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_push_commodity_for_postload_processing	(	GncSqlBackend *	be,
		gpointer *	comm
	)

Register a commodity to be committed after loading is complete.

Necessary to save corrections made while loading.

Parameters

be	SQL backend
comm	The commodity item to be committed.

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

 {
     post_load_commodities = g_list_prepend(post_load_commodities, comm);
 }

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 2348 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 536 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 177 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 3354 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 450 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 );
 
     /* 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 3176 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 );
 }

Modules

Files

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Enumeration Type Documentation

Function Documentation