GncSqlBackend Class Reference

Main SQL backend structure. More...

#include <gnc-sql-backend.hpp>

Inheritance diagram for GncSqlBackend:

Public Member Functions
	GncSqlBackend (GncSqlConnection *conn, QofBook *book)
void	load (QofBook *, QofBackendLoadType) override
	Load the contents of an SQL database into a book. More...
void	sync (QofBook *) override
	Save the contents of a book to an SQL database. More...
void	begin (QofInstance *) override
	An object is about to be edited. More...
void	commit (QofInstance *) override
	Object editing is complete and the object should be saved. More...
void	rollback (QofInstance *) override
	Object editing has been cancelled. More...
void	connect (GncSqlConnection *conn) noexcept
	Connect the backend to a GncSqlConnection. More...
void	init_version_info () noexcept
	Initializes DB table version information. More...
bool	reset_version_info () noexcept
	Resets the version table information by removing all version table info. More...
void	finalize_version_info () noexcept
	Finalizes DB table version information. More...
GncSqlStatementPtr	create_statement_from_sql (const std::string &str) const noexcept
GncSqlResultPtr	execute_select_statement (const GncSqlStatementPtr &stmt) const noexcept
	Executes an SQL SELECT statement and returns the result rows. More...
int	execute_nonselect_statement (const GncSqlStatementPtr &stmt) const noexcept
std::string	quote_string (const std::string &) const noexcept
bool	create_table (const std::string &table_name, const EntryVec &col_table) const noexcept
	Creates a table in the database. More...
bool	create_table (const std::string &table_name, int table_version, const EntryVec &col_table) noexcept
	Creates a table in the database and sets its version. More...
void	create_tables () noexcept
	Create/update all tables in the database.
bool	create_index (const std::string &index_name, const std::string &table_name, const EntryVec &col_table) const noexcept
	Creates an index in the database. More...
bool	add_columns_to_table (const std::string &table_name, const EntryVec &col_table) const noexcept
	Adds one or more columns to an existing table. More...
void	upgrade_table (const std::string &table_name, const EntryVec &col_table) noexcept
	Upgrades a table to a new structure. More...
uint_t	get_table_version (const std::string &table_name) const noexcept
	Returns the version number for a DB table. More...
bool	set_table_version (const std::string &table_name, uint_t version) noexcept
	Registers the version for a table. More...
void	commodity_for_postload_processing (gnc_commodity *)
	Register a commodity to be committed after loading is complete. More...
GncSqlObjectBackendPtr	get_object_backend (const std::string &type) const noexcept
	Get the GncSqlObjectBackend for the indicated type. More...
bool	object_in_db (const char *table_name, QofIdTypeConst obj_name, const gpointer pObject, const EntryVec &table) const noexcept
	Checks whether an object is in the database or not. More...
bool	do_db_operation (E_DB_OPERATION op, const char *table_name, QofIdTypeConst obj_name, gpointer pObject, const EntryVec &table) const noexcept
	Performs an operation on the database. More...
bool	save_commodity (gnc_commodity *comm) noexcept
	Ensure that a commodity referenced in another object is in fact saved in the database. More...
QofBook *	book () const noexcept
void	set_loading (bool loading) noexcept
bool	pristine () const noexcept
void	update_progress (double pct) const noexcept
void	finish_progress () const noexcept
Public Member Functions inherited from QofBackend
	QofBackend (const QofBackend &)=delete
	QofBackend (const QofBackend &&)=delete
virtual void	session_begin (QofSession *session, const char *new_uri, SessionOpenMode mode)=0
	Open the file or connect to the server. More...
virtual void	session_end ()=0
virtual void	safe_sync (QofBook *)=0
	Perform a sync in a way that prevents data loss on a DBI backend.
virtual void	export_coa (QofBook *)
	Extract the chart of accounts from the current database and create a new database with it. More...
void	set_error (QofBackendError err)
	Set the error value only if there isn't already an error already.
QofBackendError	get_error ()
	Retrieve the currently-stored error and clear it.
bool	check_error ()
	Report if there is an error.
void	set_message (std::string &&)
	Set a descriptive message that can be displayed to the user when there's an error.
const std::string &&	get_message ()
	Retrieve and clear the stored error message.
void	set_percentage (QofBePercentageFunc pctfn)
	Store and retrieve a backend-specific function for determining the progress in completing a long operation, for use with a progress meter.
QofBePercentageFunc	get_percentage ()
const std::string &	get_uri ()
	Retrieve the backend's storage URI.

Protected Attributes
GncSqlConnection *	m_conn = nullptr
	SQL connection.
QofBook *	m_book = nullptr
	The primary, main open book.
bool	m_loading
	We are performing an initial load.
bool	m_in_query
	We are processing a query.
bool	m_is_pristine_db
	Are we saving to a new pristine db?
const char *	m_time_format = nullptr
	Server-specific date-time string format.
VersionVec	m_versions
	Version number for each table.
Protected Attributes inherited from QofBackend
QofBePercentageFunc	m_percentage
std::string	m_fullpath
	Each backend resolves a fully-qualified file path. More...

Additional Inherited Members
Static Public Member Functions inherited from QofBackend
static bool	register_backend (const char *, const char *)
	Class methods for dynamically loading the several backends and for freeing them at shutdown.
static void	release_backends ()

Detailed Description

Main SQL backend structure.

Definition at line 63 of file gnc-sql-backend.hpp.

Member Function Documentation

add_columns_to_table()

bool GncSqlBackend::add_columns_to_table ( const std::string &  table_name, const EntryVec &  col_table  ) const

noexcept

Adds one or more columns to an existing table.

Parameters

table_name	SQL table name
new_col_table	Column table for new columns

Returns

TRUE if successful, FALSE if unsuccessful

Definition at line 182 of file gnc-sql-backend.cpp.

{
    g_return_val_if_fail (m_conn != nullptr, false);

    ColVec info_vec;

    for (auto const& table_row : col_table)
    {
        table_row->add_to_table (info_vec);
    }
    return m_conn->add_columns_to_table(table_name, info_vec);
}

begin()

void GncSqlBackend::begin ( QofInstance *  inst )

overridevirtual

An object is about to be edited.

Parameters

inst	Object being edited

Reimplemented from QofBackend.

Definition at line 543 of file gnc-sql-backend.cpp.

{
    //g_return_if_fail (inst != NULL);

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

commit()

void GncSqlBackend::commit ( QofInstance *  inst )

overridevirtual

Object editing is complete and the object should be saved.

Parameters

inst	Object being edited

Reimplemented from QofBackend.

Definition at line 577 of file gnc-sql-backend.cpp.

{
    gboolean is_dirty;
    gboolean is_destroying;
    gboolean is_infant;

    g_return_if_fail (inst != NULL);
    g_return_if_fail (m_conn != nullptr);

    if (qof_book_is_readonly(m_book))
    {
        set_error (ERR_BACKEND_READONLY);
        (void)m_conn->rollback_transaction ();
        return;
    }
    /* During initial load where objects are being created, don't commit
    anything, but do mark the object as clean. */
    if (m_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 (m_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 (!m_conn->begin_transaction ())
    {
        PERR ("begin_transaction failed\n");
        LEAVE ("Rolled back - database transaction begin error");
        return;
    }

    bool is_ok = true;

    auto obe = m_backend_registry.get_object_backend(std::string{inst->e_type});
    if (obe != nullptr)
        is_ok = obe->commit(this, inst);
    else
    {
        PERR ("Unknown object type '%s'\n", inst->e_type);
        (void)m_conn->rollback_transaction ();

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

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

    (void)m_conn->commit_transaction ();

    qof_book_mark_session_saved(m_book);
    qof_instance_mark_clean (inst);

    LEAVE ("");
}

commodity_for_postload_processing()

void GncSqlBackend::commodity_for_postload_processing

(

gnc_commodity *

commodity

)

Register a commodity to be committed after loading is complete.

Necessary to save corrections made while loading.

Parameters

comm	The commodity item to be committed.

Definition at line 561 of file gnc-sql-backend.cpp.

{
    m_postload_commodities.push_back(commodity);
}

connect()

void GncSqlBackend::connect ( GncSqlConnection *  conn )

noexcept

Connect the backend to a GncSqlConnection.

Sets up version info. Calling with nullptr clears the connection and destroys the version info.

Definition at line 94 of file gnc-sql-backend.cpp.

{
    if (m_conn != nullptr && m_conn != conn)
        delete m_conn;
    finalize_version_info();
    m_conn = conn;
}

create_index()

bool GncSqlBackend::create_index ( const std::string &  index_name, const std::string &  table_name, const EntryVec &  col_table  ) const

noexcept

Creates an index in the database.

Parameters

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 173 of file gnc-sql-backend.cpp.

{
    g_return_val_if_fail (m_conn != nullptr, false);
    return m_conn->create_index(index_name, table_name, col_table);
}

create_table() [1/2]

bool GncSqlBackend::create_table ( const std::string &  table_name, const EntryVec &  col_table  ) const

noexcept

Creates a table in the database.

Parameters

table_name	Table name
col_table	DB table description

Returns

TRUE if successful, FALSE if unsuccessful

Definition at line 148 of file gnc-sql-backend.cpp.

{
    g_return_val_if_fail (m_conn != nullptr, false);

    ColVec info_vec;

    for (auto const& table_row : col_table)
    {
        table_row->add_to_table (info_vec);
    }
    return m_conn->create_table (table_name, info_vec);

}

create_table() [2/2]

bool GncSqlBackend::create_table ( const std::string &  table_name, int  table_version, const EntryVec &  col_table  )

noexcept

Creates a table in the database and sets its version.

Parameters

table_name	Table name
table_version	Table version
col_table	DB table description

Returns

TRUE if successful, FALSE if unsuccessful

Definition at line 164 of file gnc-sql-backend.cpp.

{
    if (create_table (table_name, col_table))
        return set_table_version (table_name, table_version);
    return false;
}

do_db_operation()

bool GncSqlBackend::do_db_operation ( E_DB_OPERATION  op, const char *  table_name, QofIdTypeConst  obj_name, gpointer  pObject, const EntryVec &  table  ) const

noexcept

Performs an operation on the database.

Parameters

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 854 of file gnc-sql-backend.cpp.

{
    GncSqlStatementPtr stmt;

    g_return_val_if_fail (table_name != nullptr, false);
    g_return_val_if_fail (obj_name != nullptr, false);
    g_return_val_if_fail (pObject != nullptr, false);

    switch(op)
    {
        case  OP_DB_INSERT:
        stmt = build_insert_statement (table_name, obj_name, pObject, table);
        break;
        case OP_DB_UPDATE:
        stmt = build_update_statement (table_name, obj_name, pObject, table);
        break;
        case OP_DB_DELETE:
        stmt = build_delete_statement (table_name, obj_name, pObject, table);
        break;
    }
    if (stmt == nullptr)
        return false;
    return (execute_nonselect_statement(stmt) != -1);
}

execute_select_statement()

GncSqlResultPtr GncSqlBackend::execute_select_statement ( const GncSqlStatementPtr &  stmt ) const

noexcept

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 nullptr is returned.

Parameters

statement

Statement

Returns

Results, or nullptr if an error has occurred

Definition at line 115 of file gnc-sql-backend.cpp.

{
    auto result = m_conn ? m_conn->execute_select_statement(stmt) : nullptr;
    if (result == nullptr)
    {
        PERR ("SQL error: %s\n", stmt->to_sql());
        qof_backend_set_error ((QofBackend*)this, ERR_BACKEND_SERVER_ERR);
    }
    return result;
}

finalize_version_info()

void GncSqlBackend::finalize_version_info ( )

noexcept

Finalizes DB table version information.

Finalizes the version table info by destroying the hash table.

Parameters

be	Backend struct

Definition at line 721 of file gnc-sql-backend.cpp.

{
    m_versions.clear();
}

get_object_backend()

GncSqlObjectBackendPtr GncSqlBackend::get_object_backend ( const std::string &  type ) const

noexcept

Get the GncSqlObjectBackend for the indicated type.

Required because we need to pass a pointer to this to a callback via a C function.

Parameters

type	The QofInstance type constant to select the object backend.

Definition at line 567 of file gnc-sql-backend.cpp.

{
    return m_backend_registry.get_object_backend(type);
}

get_table_version()

unsigned int GncSqlBackend::get_table_version ( const std::string &  table_name ) const

noexcept

Returns the version number for a DB table.

Parameters

table_name

Table name

Returns

Version number, or 0 if the table does not exist

Definition at line 727 of file gnc-sql-backend.cpp.

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

    auto version = std::find_if(m_versions.begin(), m_versions.end(),
                                [table_name](const VersionPair& version) {
                                    return version.first == table_name; });
    if (version != m_versions.end())
        return version->second;
    return 0;
}

init_version_info()

void GncSqlBackend::init_version_info ( )

noexcept

Initializes DB table version information.

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 673 of file gnc-sql-backend.cpp.

{
    g_return_if_fail (m_conn != nullptr);
    if (m_conn->does_table_exist (VERSION_TABLE_NAME))
    {
        std::string sql {"SELECT * FROM "};
        sql += VERSION_TABLE_NAME;
        auto stmt = m_conn->create_statement_from_sql(sql);
        auto result = m_conn->execute_select_statement (stmt);
        for (const auto& row : *result)
        {
            auto name = row.get_string_at_col (TABLE_COL_NAME);
            auto version = row.get_int_at_col (VERSION_COL_NAME);
            if (name && version)
                m_versions.push_back(std::make_pair(*name, static_cast<unsigned int>(*version)));
        }
    }
    else
    {
        create_table (VERSION_TABLE_NAME, version_table);
        set_table_version("Gnucash", gnc_prefs_get_long_version ());
        set_table_version("Gnucash-Resave", GNUCASH_RESAVE_VERSION);
    }
}

load()

void GncSqlBackend::load ( QofBook *  book, QofBackendLoadType  loadType  )

overridevirtual

Load the contents of an SQL database into a book.

Parameters

book	Book to be loaded

Implements QofBackend.

Definition at line 283 of file gnc-sql-backend.cpp.

{
    Account* root;

    g_return_if_fail (book != NULL);

    ENTER ("sql_be=%p, book=%p", this, book);

    m_loading = TRUE;

    if (loadType == LOAD_TYPE_INITIAL_LOAD)
    {
        assert (m_book == nullptr);
        m_book = book;

        auto num_types = m_backend_registry.size();
        auto num_done = 0;

        /* Load any initial stuff. Some of this needs to happen in a certain order */
        for (const auto& type : fixed_load_order)
        {
            num_done++;
            auto obe = m_backend_registry.get_object_backend(type);
            if (obe)
            {
                update_progress(num_done * 100 / num_types);
                obe->load_all(this);
            }
        }
        for (const auto& type : business_fixed_load_order)
        {
            num_done++;
            auto obe = m_backend_registry.get_object_backend(type);
            if (obe)
            {
                update_progress(num_done * 100 / num_types);
                obe->load_all(this);
            }
        }

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

        m_backend_registry.load_remaining(this);

        gnc_account_foreach_descendant(root, (AccountCb)xaccAccountCommitEdit,
                                       nullptr);
    }
    else if (loadType == LOAD_TYPE_LOAD_ALL)
    {
        // Load all transactions
        auto obe = m_backend_registry.get_object_backend (GNC_ID_TRANS);
        obe->load_all (this);
    }

    m_loading = FALSE;
    std::for_each(m_postload_commodities.begin(), m_postload_commodities.end(),
                 [](gnc_commodity* comm) {
                      gnc_commodity_begin_edit(comm);
                      gnc_commodity_commit_edit(comm);
                  });
    m_postload_commodities.clear();
    /* We deferred the transaction scrub while loading because having
     * m_loading true prevents changes from being written back to the
     * database. Do that now.
     */
    auto transactions = qof_book_get_collection (book, GNC_ID_TRANS);
    qof_collection_foreach(transactions, scrub_txn_callback, nullptr);

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

    LEAVE ("");
}

object_in_db()

bool GncSqlBackend::object_in_db ( const char *  table_name, QofIdTypeConst  obj_name, const gpointer  pObject, const EntryVec &  table  ) const

noexcept

Checks whether an object is in the database or not.

Parameters

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 832 of file gnc-sql-backend.cpp.

{
    g_return_val_if_fail (table_name != nullptr, false);
    g_return_val_if_fail (obj_name != nullptr, false);
    g_return_val_if_fail (pObject != nullptr, false);

    /* SELECT * FROM */
    auto sql = std::string{"SELECT "} + table[0]->name() + " FROM " + table_name;
    auto stmt = create_statement_from_sql(sql.c_str());
    assert (stmt != nullptr);

    /* WHERE */
    PairVec values{get_object_values(obj_name, pObject, table)};
    /* We want only the first item in the table, which should be the PK. */
    values.resize(1);
    stmt->add_where_cond(obj_name, values);
    auto result = execute_select_statement (stmt);
    return (result != nullptr && result->size() > 0);
}

reset_version_info()

bool GncSqlBackend::reset_version_info ( )

noexcept

Resets the version table information by removing all version table info.

It also recreates the version table in the db.

Parameters

be	Backend struct

Returns

TRUE if successful, FALSE if error

Definition at line 706 of file gnc-sql-backend.cpp.

{
    bool ok = create_table (VERSION_TABLE_NAME, version_table);
    m_versions.clear();
    set_table_version ("Gnucash", gnc_prefs_get_long_version ());
    set_table_version ("Gnucash-Resave", GNUCASH_RESAVE_VERSION);
    return ok;
}

rollback()

void GncSqlBackend::rollback ( QofInstance *  inst )

overridevirtual

Object editing has been cancelled.

Parameters

inst	Object being edited

Reimplemented from QofBackend.

Definition at line 552 of file gnc-sql-backend.cpp.

{
    //g_return_if_fail (inst != NULL);

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

save_commodity()

bool GncSqlBackend::save_commodity ( gnc_commodity *  comm )

noexcept

Ensure that a commodity referenced in another object is in fact saved in the database.

Parameters

comm	The commodity in question

Returns

true if the commodity needed to be saved.

Definition at line 882 of file gnc-sql-backend.cpp.

{
    if (comm == nullptr) return false;
    QofInstance* inst = QOF_INSTANCE(comm);
    auto obe = m_backend_registry.get_object_backend(std::string(inst->e_type));
    if (obe && !obe->instance_in_db(this, inst))
        return obe->commit(this, inst);
    return true;
}

set_table_version()

bool GncSqlBackend::set_table_version ( const std::string &  table_name, uint_t  version  )

noexcept

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 751 of file gnc-sql-backend.cpp.

{
    g_return_val_if_fail (version > 0, false);

    unsigned int cur_version{0};
    std::stringstream sql;
    auto ver_entry = std::find_if(m_versions.begin(), m_versions.end(),
                                [table_name](const VersionPair& ver) {
                                    return ver.first == table_name; });
    if (ver_entry != m_versions.end())
        cur_version = ver_entry->second;
    if (cur_version != version)
    {
        if (cur_version == 0)
        {
            sql << "INSERT INTO " << VERSION_TABLE_NAME << " VALUES('" <<
                table_name << "'," << version <<")";
            m_versions.push_back(std::make_pair(table_name, version));
        }
        else
        {
            sql << "UPDATE " <<  VERSION_TABLE_NAME << " SET " <<
                VERSION_COL_NAME << "=" << version << " WHERE " <<
                TABLE_COL_NAME << "='" << table_name << "'";
            ver_entry->second = version;
        }
        auto stmt = create_statement_from_sql(sql.str());
        auto status = execute_nonselect_statement (stmt);
        if (status == -1)
        {
            PERR ("SQL error: %s\n", sql.str().c_str());
            qof_backend_set_error ((QofBackend*)this, ERR_BACKEND_SERVER_ERR);
            return false;
        }
    }

    return true;
}

sync()

void GncSqlBackend::sync ( QofBook *  book )

overridevirtual

Save the contents of a book to an SQL database.

Parameters

book	Book to be saved

Implements QofBackend.

Definition at line 472 of file gnc-sql-backend.cpp.

{
    g_return_if_fail (book != NULL);
    g_return_if_fail (m_conn != nullptr);

    reset_version_info();
    ENTER ("book=%p, sql_be->book=%p", book, m_book);
    update_progress(101.0);

    /* Create new tables */
    m_is_pristine_db = true;
    create_tables();

    /* Save all contents */
    m_book = book;
    auto is_ok = m_conn->begin_transaction();

    // FIXME: should write the set of commodities that are used
    // write_commodities(sql_be, book);
    if (is_ok)
    {
        auto obe = m_backend_registry.get_object_backend(GNC_ID_BOOK);
        is_ok = obe->commit (this, QOF_INSTANCE (book));
    }
    if (is_ok)
    {
        is_ok = write_accounts();
    }
    if (is_ok)
    {
        is_ok = write_transactions();
    }
    if (is_ok)
    {
        is_ok = write_template_transactions();
    }
    if (is_ok)
    {
        is_ok = write_schedXactions();
    }
    if (is_ok)
    {
        for (auto entry : m_backend_registry)
            std::get<1>(entry)->write (this);
    }
    if (is_ok)
    {
        is_ok = m_conn->commit_transaction();
    }
    if (is_ok)
    {
        m_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
    {
        set_error (ERR_BACKEND_SERVER_ERR);
        m_conn->rollback_transaction ();
    }
    finish_progress();
    LEAVE ("book=%p", book);
}

upgrade_table()

void GncSqlBackend::upgrade_table ( const std::string &  table_name, const EntryVec &  col_table  )

noexcept

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

table_name	SQL table name
col_table	Column table

Definition at line 792 of file gnc-sql-backend.cpp.

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

    auto temp_table_name = table_name + "_new";
    create_table (temp_table_name, col_table);
    std::stringstream sql;
    sql << "INSERT INTO " << temp_table_name << " SELECT * FROM " << table_name;
    auto stmt = create_statement_from_sql(sql.str());
    execute_nonselect_statement(stmt);

    sql.str("");
    sql << "DROP TABLE " << table_name;
    stmt = create_statement_from_sql(sql.str());
    execute_nonselect_statement(stmt);

    sql.str("");
    sql << "ALTER TABLE " << temp_table_name << " RENAME TO " << table_name;
    stmt = create_statement_from_sql(sql.str());
    execute_nonselect_statement(stmt);
}

---

The documentation for this class was generated from the following files:

• gnc-sql-backend.hpp
• gnc-sql-backend.cpp