GncSqlAccountBackend Class Reference

Inheritance diagram for GncSqlAccountBackend:

Public Member Functions
void	load_all (GncSqlBackend *) override
	Load all objects of m_type in the database into memory.
bool	commit (GncSqlBackend *, QofInstance *) override
	UPDATE/INSERT a single instance of m_type_name into the database.
Public Member Functions inherited from GncSqlObjectBackend
	GncSqlObjectBackend (int version, const std::string &type, const std::string &table, const EntryVec &vec)
virtual void	create_tables (GncSqlBackend *sql_be)
	Conditionally create or update a database table from m_col_table.
virtual bool	write (GncSqlBackend *sql_be)
	Write all objects of m_type_name to the database.
const char *	type () const noexcept
	Return the m_type_name for the class.
const bool	is_version (int version) const noexcept
	Compare a version with the compiled version (m_version).
bool	instance_in_db (const GncSqlBackend *sql_be, QofInstance *inst) const noexcept
	Check the presence of an object in the backend's database.

Additional Inherited Members
Protected Attributes inherited from GncSqlObjectBackend
const std::string	m_table_name
const int	m_version
const std::string	m_type_name
const EntryVec &	m_col_table
	The front-end QofIdType.

Detailed Description

Definition at line 34 of file gnc-account-sql.h.

Constructor & Destructor Documentation

GncSqlAccountBackend()

GncSqlAccountBackend::GncSqlAccountBackend

(

)

Definition at line 100 of file gnc-account-sql.cpp.

                                           :
    GncSqlObjectBackend(TABLE_VERSION, GNC_ID_ACCOUNT,
                        TABLE_NAME, col_table) {}

Member Function Documentation

commit()

bool GncSqlAccountBackend::commit ( GncSqlBackend *  sql_be, QofInstance *  inst  )

overridevirtual

UPDATE/INSERT a single instance of m_type_name into the database.

Parameters

sql_be	The GncSqlBackend containing the database.
inst	The QofInstance to be written out.

Reimplemented from GncSqlObjectBackend.

Definition at line 278 of file gnc-account-sql.cpp.

{
    Account* pAcc = GNC_ACCOUNT (inst);
    const GncGUID* guid;
    gboolean is_infant;
    gboolean is_ok = FALSE;
    gnc_commodity* commodity;
    E_DB_OPERATION op;
 
    g_return_val_if_fail (sql_be != NULL, FALSE);
    g_return_val_if_fail (inst != NULL, FALSE);
    g_return_val_if_fail (GNC_IS_ACCOUNT (inst), FALSE);
 
    ENTER ("inst=%p", inst);
 
    is_infant = qof_instance_get_infant (inst);
 
    // If there is no commodity yet, this might be because a new account name
    // has been entered directly into the register and an account window will
    // be opened.  The account info is not complete yet, but the name has been
    // set, triggering this commit
    commodity = xaccAccountGetCommodity (pAcc);
 
    is_ok = TRUE;
    if (qof_instance_get_destroying (inst))
    {
        op = OP_DB_DELETE;
    }
    else if (sql_be->pristine() || is_infant)
    {
        op = OP_DB_INSERT;
    }
    else
    {
        op = OP_DB_UPDATE;
    }
 
    // If not deleting the account, ensure the commodity is in the db
    if (op != OP_DB_DELETE && commodity != NULL)
    {
        is_ok = sql_be->save_commodity(commodity);
    }
 
    if (is_ok)
    {
        is_ok = sql_be->do_db_operation (op, TABLE_NAME, GNC_ID_ACCOUNT, pAcc,
                                         col_table);
    }
 
    if (is_ok)
    {
        // Now, commit or delete any slots
        guid = qof_instance_get_guid (inst);
        if (!qof_instance_get_destroying (inst))
        {
            is_ok = gnc_sql_slots_save (sql_be, guid, is_infant, inst);
        }
        else
        {
            is_ok = gnc_sql_slots_delete (sql_be, guid);
        }
    }
 
    LEAVE ("is_ok=%d", is_ok);
 
    return is_ok;
}

load_all()

void GncSqlAccountBackend::load_all ( GncSqlBackend *  sql_be )

overridevirtual

Load all objects of m_type in the database into memory.

Parameters

sql_be

The GncSqlBackend containing the database connection.

Implements GncSqlObjectBackend.

Definition at line 210 of file gnc-account-sql.cpp.

{
    QofBook* pBook;
    ParentGuidVec l_accounts_needing_parents;
    g_return_if_fail (sql_be != NULL);
 
    ENTER ("");
 
    pBook = sql_be->book();
 
    std::string sql("SELECT * FROM " TABLE_NAME);
    auto stmt = sql_be->create_statement_from_sql(sql);
    auto result = sql_be->execute_select_statement(stmt);
    for (auto row : *result)
        load_single_account (sql_be, row, l_accounts_needing_parents);
 
    sql = "SELECT DISTINCT guid FROM " TABLE_NAME;
    gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
                                         (BookLookupFn)xaccAccountLookup);
 
    /* While there are items on the list of accounts needing parents,
       try to see if the parent has now been loaded.  Theory says that if
       items are removed from the front and added to the back if the
       parent is still not available, then eventually, the list will
       shrink to size 0. */
    if (!l_accounts_needing_parents.empty())
    {
        auto progress_made = true;
        std::reverse(l_accounts_needing_parents.begin(),
                     l_accounts_needing_parents.end());
    auto end = l_accounts_needing_parents.end();
        while (progress_made)
        {
            progress_made = false;
            end = std::remove_if(l_accounts_needing_parents.begin(), end,
                 [&](ParentGuidPtr s)
                 {
                     auto pParent = xaccAccountLookup (&s->guid,
                                       sql_be->book());
                     if (pParent != nullptr)
                     {
                     gnc_account_append_child (pParent,
                                   s->pAccount);
                     progress_made = true;
                     delete s;
                     return true;
                     }
                     return false;
                 });
        }
 
        /* Any non-ROOT accounts left over must be parented by the root account */
        auto root = gnc_book_get_root_account (pBook);
        end = std::remove_if(l_accounts_needing_parents.begin(), end,
                 [&](ParentGuidPtr s)
                 {
                 if (xaccAccountGetType (s->pAccount) != ACCT_TYPE_ROOT)
                     gnc_account_append_child (root, s->pAccount);
                 delete s;
                 return true;
                 });
    }
 
    LEAVE ("");
}

---

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

• gnc-account-sql.h
• gnc-account-sql.cpp