IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Reduce use of gnc_sql_slots_load_for_instancevec.

Browse Source
This commit is contained in:
John Ralls
2018-03-24 17:55:03 -07:00
parent a39ba1672a
commit e4d0ad9dda
16 changed files with 167 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libgnucash/backend/sql/gnc-account-sql.cpp
View File

@@ -220,16 +220,14 @@ GncSqlAccountBackend::load_all (GncSqlBackend* sql_be)
pBook = sql_be->book();
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
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.str("");
sql << "SELECT DISTINCT guid FROM " << TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql.str().c_str(),
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,

23
libgnucash/backend/sql/gnc-bill-term-sql.cpp
View File

@@ -224,30 +224,35 @@ load_single_billterm (GncSqlBackend* sql_be, GncSqlRow& row,
return pBillTerm;
}
/* Because gncBillTermLookup has the arguments backwards: */
static inline GncBillTerm*
gnc_billterm_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_BILLTERM, GncBillTerm);
}
void
GncSqlBillTermBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
BillTermParentGuidVec l_billterms_needing_parents;
for (auto row : *result)
{
auto pBillTerm =
load_single_billterm (sql_be, row, l_billterms_needing_parents);
if (pBillTerm != nullptr)
instances.push_back(QOF_INSTANCE(pBillTerm));
}
delete result;
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_billterm_lookup);
/* While there are items on the list of billterms needing parents,
try to see if the parent has now been loaded. Theory says that if

17
libgnucash/backend/sql/gnc-budget-sql.cpp
View File

@@ -327,22 +327,19 @@ load_single_budget (GncSqlBackend* sql_be, GncSqlRow& row)
void
GncSqlBudgetBackend::load_all (GncSqlBackend* sql_be)
{
InstanceVec instances;
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << BUDGET_TABLE;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " BUDGET_TABLE);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
{
auto b = load_single_budget (sql_be, row);
if (b != nullptr)
instances.push_back(QOF_INSTANCE(b));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " BUDGET_TABLE;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_budget_lookup);
}
/* ================================================================= */

14
libgnucash/backend/sql/gnc-commodity-sql.cpp
View File

@@ -142,9 +142,8 @@ GncSqlCommodityBackend::load_all (GncSqlBackend* sql_be)
gnc_commodity_table* pTable;
pTable = gnc_commodity_table_get_table (sql_be->book());
std::stringstream sql;
sql << "SELECT * FROM " << COMMODITIES_TABLE;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " COMMODITIES_TABLE);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
@@ -162,11 +161,12 @@ GncSqlCommodityBackend::load_all (GncSqlBackend* sql_be)
qof_instance_set_guid (QOF_INSTANCE (pCommodity), &guid);
}
auto sql = g_strdup_printf ("SELECT DISTINCT guid FROM %s", COMMODITIES_TABLE);
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_commodity_find_commodity_by_guid);
g_free (sql);
}
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " COMMODITIES_TABLE;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_commodity_find_commodity_by_guid);
}
/* ================================================================= */
static gboolean

24
libgnucash/backend/sql/gnc-customer-sql.cpp
View File

@@ -117,26 +117,30 @@ load_single_customer (GncSqlBackend* sql_be, GncSqlRow& row)
return pCustomer;
}
/* Because gncCustomerLookup has the arguments backwards: */
static inline GncCustomer*
gnc_customer_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_CUSTOMER, GncCustomer);
}
void
GncSqlCustomerBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncCustomer* pCustomer = load_single_customer (sql_be, row);
if (pCustomer != nullptr)
instances.push_back(QOF_INSTANCE(pCustomer));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_customer_lookup);
}
/* ================================================================= */

25
libgnucash/backend/sql/gnc-employee-sql.cpp
View File

@@ -101,30 +101,33 @@ load_single_employee (GncSqlBackend* sql_be, GncSqlRow& row)
return pEmployee;
}
/* Because gncCustomerLookup has the arguments backwards: */
static inline GncEmployee*
gnc_employee_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_EMPLOYEE, GncEmployee);
}
void
GncSqlEmployeeBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncEmployee* pEmployee = load_single_employee (sql_be, row);
if (pEmployee != nullptr)
instances.push_back(QOF_INSTANCE(pEmployee));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_employee_lookup);
}
/* ================================================================= */
void
GncSqlEmployeeBackend::create_tables (GncSqlBackend* sql_be)

24
libgnucash/backend/sql/gnc-entry-sql.cpp
View File

@@ -186,26 +186,30 @@ load_single_entry (GncSqlBackend* sql_be, GncSqlRow& row)
return pEntry;
}
/* Because gncEntryLookup has the arguments backwards: */
static inline GncEntry*
gnc_entry_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_ENTRY, GncEntry);
}
void
GncSqlEntryBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncEntry* pEntry = load_single_entry (sql_be, row);
if (pEntry != nullptr)
instances.push_back(QOF_INSTANCE(pEntry));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec(sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_entry_lookup);
}
/* ================================================================= */

24
libgnucash/backend/sql/gnc-invoice-sql.cpp
View File

@@ -124,26 +124,30 @@ load_single_invoice (GncSqlBackend* sql_be, GncSqlRow& row)
return pInvoice;
}
/* Because gncInvoiceLookup has the arguments backwards: */
static inline GncInvoice*
gnc_invoice_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_INVOICE, GncInvoice);
}
void
GncSqlInvoiceBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncInvoice* pInvoice = load_single_invoice (sql_be, row);
if (pInvoice != nullptr)
instances.push_back(QOF_INSTANCE(pInvoice));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_invoice_lookup);
}
/* ================================================================= */

24
libgnucash/backend/sql/gnc-job-sql.cpp
View File

@@ -96,26 +96,30 @@ load_single_job (GncSqlBackend* sql_be, GncSqlRow& row)
return pJob;
}
/* Because gncJobLookup has the arguments backwards: */
static inline GncJob*
gnc_job_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_JOB, GncJob);
}
void
GncSqlJobBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncJob* pJob = load_single_job (sql_be, row);
if (pJob != nullptr)
instances.push_back(QOF_INSTANCE(pJob));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_job_lookup);
}
/* ================================================================= */

24
libgnucash/backend/sql/gnc-order-sql.cpp
View File

@@ -98,26 +98,30 @@ load_single_order (GncSqlBackend* sql_be, GncSqlRow& row)
return pOrder;
}
/* Because gncOrderLookup has the arguments backwards: */
static inline GncOrder*
gnc_order_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_ORDER, GncOrder);
}
void
GncSqlOrderBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncOrder* pOrder = load_single_order (sql_be, row);
if (pOrder != nullptr)
instances.push_back(QOF_INSTANCE(pOrder));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_order_lookup);
}
/* ================================================================= */

15
libgnucash/backend/sql/gnc-price-sql.cpp
View File

@@ -102,9 +102,8 @@ GncSqlPriceBackend::load_all (GncSqlBackend* sql_be)
pBook = sql_be->book();
pPriceDB = gnc_pricedb_get_db (pBook);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
if (stmt != nullptr)
{
auto result = sql_be->execute_select_statement(stmt);
@@ -112,7 +111,6 @@ GncSqlPriceBackend::load_all (GncSqlBackend* sql_be)
return;
GNCPrice* pPrice;
gchar* sql;
gnc_pricedb_set_bulk_update (pPriceDB, TRUE);
for (auto row : *result)
@@ -126,10 +124,11 @@ GncSqlPriceBackend::load_all (GncSqlBackend* sql_be)
}
}
gnc_pricedb_set_bulk_update (pPriceDB, FALSE);
sql = g_strdup_printf ("SELECT DISTINCT guid FROM %s", TABLE_NAME);
gnc_sql_slots_load_for_sql_subquery (sql_be, sql, (BookLookupFn)gnc_price_lookup);
g_free (sql);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_price_lookup);
}
}

26
libgnucash/backend/sql/gnc-schedxaction-sql.cpp
View File

@@ -115,18 +115,23 @@ load_single_sx (GncSqlBackend* sql_be, GncSqlRow& row)
return pSx;
}
/* Because SchedXaction doesn't define a lookup function: */
static inline SchedXaction*
gnc_sx_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_SCHEDXACTION, SchedXaction);
}
void
GncSqlSchedXactionBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << SCHEDXACTION_TABLE;
auto stmt = sql_be->create_statement_from_sql(sql.str());
if (stmt == NULL) return;
std::string sql("SELECT * FROM " SCHEDXACTION_TABLE);
auto stmt = sql_be->create_statement_from_sql(sql);
if (stmt == nullptr) return;
auto result = sql_be->execute_select_statement(stmt);
SchedXactions* sxes;
InstanceVec instances;
sxes = gnc_book_get_schedxactions (sql_be->book());
for (auto row : *result)
@@ -135,14 +140,13 @@ GncSqlSchedXactionBackend::load_all (GncSqlBackend* sql_be)
sx = load_single_sx (sql_be, row);
if (sx != nullptr)
{
gnc_sxes_add_sx (sxes, sx);
instances.push_back(QOF_INSTANCE(sx));
}
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " SCHEDXACTION_TABLE;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_sx_lookup);
}

28
libgnucash/backend/sql/gnc-slots-sql.cpp
View File

@@ -766,19 +766,15 @@ gnc_sql_slots_load (GncSqlBackend* sql_be, QofInstance* inst)
static void
slots_load_info (slot_info_t* pInfo)
{
gchar guid_buf[GUID_ENCODING_LENGTH + 1];
g_return_if_fail (pInfo != NULL);
g_return_if_fail (pInfo->be != NULL);
g_return_if_fail (pInfo->guid != NULL);
g_return_if_fail (pInfo->pKvpFrame != NULL);
(void)guid_to_string_buff (pInfo->guid, guid_buf);
std::stringstream buf;
buf << "SELECT * FROM " << TABLE_NAME <<
" WHERE obj_guid='" << guid_buf << "'";
auto stmt = pInfo->be->create_statement_from_sql (buf.str());
gnc::GUID guid(*pInfo->guid);
std::string sql("SELECT * FROM " TABLE_NAME " WHERE obj_guid='");
sql += guid.to_string() + "'";
auto stmt = pInfo->be->create_statement_from_sql(sql);
if (stmt != nullptr)
{
auto result = pInfo->be->execute_select_statement (stmt);
@@ -897,29 +893,25 @@ load_slot_for_book_object (GncSqlBackend* sql_be, GncSqlRow& row,
* @param lookup_fn Lookup function
*/
void gnc_sql_slots_load_for_sql_subquery (GncSqlBackend* sql_be,
const gchar* subquery,
const std::string subquery,
BookLookupFn lookup_fn)
{
gchar* sql;
g_return_if_fail (sql_be != NULL);
// Ignore empty subquery
if (subquery == NULL) return;
if (subquery.empty()) return;
sql = g_strdup_printf ("SELECT * FROM %s WHERE %s IN (%s)",
TABLE_NAME, obj_guid_col_table[0]->name(),
subquery);
std::string pkey(obj_guid_col_table[0]->name());
std::string sql("SELECT * FROM " TABLE_NAME " WHERE ");
sql += pkey + " IN (" + subquery + ")";
// Execute the query and load the slots
auto stmt = sql_be->create_statement_from_sql(sql);
if (stmt == nullptr)
{
PERR ("stmt == NULL, SQL = '%s'\n", sql);
g_free (sql);
PERR ("stmt == NULL, SQL = '%s'\n", sql.c_str());
return;
}
g_free (sql);
auto result = sql_be->execute_select_statement(stmt);
for (auto row : *result)
load_slot_for_book_object (sql_be, row, lookup_fn);

2
libgnucash/backend/sql/gnc-slots-sql.h
View File

@@ -100,7 +100,7 @@ typedef QofInstance* (*BookLookupFn) (const GncGUID* guid,
* @param lookup_fn Lookup function to get the right object from the book
*/
void gnc_sql_slots_load_for_sql_subquery (GncSqlBackend* sql_be,
const gchar* subquery,
const std::string subquery,
BookLookupFn lookup_fn);
void gnc_sql_init_slots_handler (void);

12
libgnucash/backend/sql/gnc-transaction-sql.cpp
View File

@@ -264,17 +264,13 @@ load_splits_for_tx_list (GncSqlBackend* sql_be, InstanceVec& transactions)
// Execute the query and load the splits
auto stmt = sql_be->create_statement_from_sql(sql.str());
auto result = sql_be->execute_select_statement (stmt);
InstanceVec instances;
for (auto row : *result)
{
Split* s = load_single_split (sql_be, row);
if (s != nullptr)
instances.push_back(QOF_INSTANCE(s));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
sql = "SELECT DISTINCT ";
sql += spkey + " FROM " SPLIT_TABLE " WHERE " + sskey + " IN " + selector;
gnc_sql_slots_load_for_sql_subquery(sql_be, sql,
(BookLookupFn)xaccSplitLookup);
}
static Transaction*

24
libgnucash/backend/sql/gnc-vendor-sql.cpp
View File

@@ -106,26 +106,30 @@ load_single_vendor (GncSqlBackend* sql_be, GncSqlRow& row)
return pVendor;
}
/* Because gncVendorLookup has the arguments backwards: */
static inline GncVendor*
gnc_vendor_lookup (const GncGUID *guid, const QofBook *book)
{
QOF_BOOK_RETURN_ENTITY(book, guid, GNC_ID_VENDOR, GncVendor);
}
void
GncSqlVendorBackend::load_all (GncSqlBackend* sql_be)
{
g_return_if_fail (sql_be != NULL);
std::stringstream sql;
sql << "SELECT * FROM " << TABLE_NAME;
auto stmt = sql_be->create_statement_from_sql(sql.str());
std::string sql("SELECT * FROM " TABLE_NAME);
auto stmt = sql_be->create_statement_from_sql(sql);
auto result = sql_be->execute_select_statement(stmt);
InstanceVec instances;
for (auto row : *result)
{
GncVendor* pVendor = load_single_vendor (sql_be, row);
if (pVendor != nullptr)
instances.push_back(QOF_INSTANCE(pVendor));
}
if (!instances.empty())
gnc_sql_slots_load_for_instancevec (sql_be, instances);
std::string pkey(col_table[0]->name());
sql = "SELECT DISTINCT ";
sql += pkey + " FROM " TABLE_NAME;
gnc_sql_slots_load_for_sql_subquery (sql_be, sql,
(BookLookupFn)gnc_vendor_lookup);
}
/* ================================================================= */