commit 6e4119a4997a88b471b821f89ecad05a2a0cc91d Author: David Sorber Date: Thu Jan 19 15:32:03 2017 -0500 I finally got back to working on this POC, and I was able to get it mostly working. The only issue right now is that the template magic is attempting to create code for which the types don't match and don't cast decay nicely. That is if you try to assign a std::string to a tuple. Hopefully I can fix this with a bit of massaging. diff --git a/software/sqlite_poc/DBManager.cc b/software/sqlite_poc/DBManager.cc index b15c2d3..188c82c 100644 --- a/software/sqlite_poc/DBManager.cc +++ b/software/sqlite_poc/DBManager.cc @@ -12,26 +12,11 @@ DBManager::DBManager(const std::string& db_path) } else { - std::cout << "WORKED" << std::endl; + std::cout << "DB connected\n" << std::endl; } - - numba = 17; - } DBManager::~DBManager() { sqlite3_close(this->db); } - -void DBManager::test() -{ - std::cout << "Numba: " << numba << std::endl; -} - - -//~ template -//~ void DBManager::func(T foo) -//~ { - //~ std::cout << "Does this work??? " << foo << std::endl; -//~ } diff --git a/software/sqlite_poc/DBManager.h b/software/sqlite_poc/DBManager.h index 6494384..b9c699a 100644 --- a/software/sqlite_poc/DBManager.h +++ b/software/sqlite_poc/DBManager.h @@ -7,49 +7,47 @@ #include -template -struct visit_impl +template +struct builder_impl { - template - static void visit(T& tup, size_t idx, V value) + template + static void set_value(T& tup, size_t idx, G& val) { - if (idx == I - 1) + if (idx == I - 1) { - if (std::is_same(tup), value>) - { - std::get(tup) = value; - } - else - { - assert(false); - } + std::get(tup) = val; } else { - visit_impl::visit(tup, idx, value); + builder_impl::set_value(tup, idx, val); } } }; template <> -struct visit_impl<0> +struct builder_impl<0> { - template - static void visit(T& tup, size_t idx, V fun) { assert(false); } + template + static void set_value(T& tup, size_t idx, G& val) + { + assert(false); + } }; + +template +void set_value_at(std::tuple& tup, size_t idx, G const& val) +{ + builder_impl::set_value(tup, idx, val); +} -//~ template -//~ void visit_at(std::tuple const& tup, size_t idx, V value) -//~ { - //~ visit_impl::visit(tup, idx, value); -//~ } - -template -void visit_at(std::tuple& tup, size_t idx, V value) +template +void set_value_at(std::tuple& tup, size_t idx, G& val) { - visit_impl::visit(tup, idx, value); + builder_impl::set_value(tup, idx, val); } + + class DBManager { public: @@ -61,8 +59,8 @@ class DBManager ~DBManager(); // execute query - template - std::vector* execute_query( + template + std::vector*>* execute_query( const std::string& sql_statement, int& return_code) { @@ -76,18 +74,14 @@ class DBManager return nullptr; } - auto output_vector = new std::vector(); - - int step_return = 0; + auto output_vector = new std::vector*>(); // Iterate until we've collected all the output - do + int step_return = 0; + while ((step_return = sqlite3_step(sqlite_statement)) != SQLITE_DONE) { - // Gran the - step_return = sqlite3_step(sqlite_statement); - // Create a new result row to be populated below - auto result_row = new T(); + auto result_row = new std::tuple(); // Iterate over the columns in the row int num_cols = sqlite3_data_count(sqlite_statement); @@ -95,58 +89,39 @@ class DBManager { switch(sqlite3_column_type(sqlite_statement, col_idx)) { - case SQLITE_INTEGER: - visit_at(*result_row, col_idx, - sqlite3_column_int64(sqlite_statement, col_idx)); - - //~ std::get(result_row) = - //~ sqlite3_column_int64(sqlite_statement, col_idx); + case SQLITE_INTEGER: + set_value_at(*result_row, col_idx, + sqlite3_column_int64(sqlite_statement, + col_idx)); break; case SQLITE_FLOAT: - visit_at(*result_row, col_idx, sqlite3_column_double(sqlite_statement, col_idx)); - //~ std::get(result_row) = - //~ sqlite3_column_double(sqlite_statement, col_idx); + set_value_at(*result_row, col_idx, + sqlite3_column_double(sqlite_statement, + col_idx)); break; case SQLITE_TEXT: - visit_at(*result_row, col_idx, - std::string(reinterpret_cast(sqlite3_column_text(sqlite_statement, col_idx)))); - - //~ std::get(result_row) = - //~ std::string(sqlite3_column_text(sqlite_statement, col_idx)); + //~ set_value_at(*result_row, col_idx, + //~ std::string(reinterpret_cast(sqlite3_column_text(sqlite_statement, col_idx)))); break; case SQLITE_BLOB: break; case SQLITE_NULL: + //~ set_value_at(*result_row, col_idx, std::string("")); break; } } - + output_vector->push_back(result_row); } - while (step_return == SQLITE_ROW); return output_vector; } - void test(); - - // templatized member function! - template - std::vector func(T& foo) - { - std::cout << "Does this work??? " << std::get<2>(foo) << std::endl; - - std::vector bar; - bar.push_back(foo); - return bar; - } - private: sqlite3 *db; - uint32_t numba; }; diff --git a/software/sqlite_poc/main.cc b/software/sqlite_poc/main.cc index 2956cfa..15a6edf 100644 --- a/software/sqlite_poc/main.cc +++ b/software/sqlite_poc/main.cc @@ -1,31 +1,65 @@ - +#include #include #include #include "DBManager.h" +// helper function to print a tuple of any size +template +struct TuplePrinter { + static void print(const Tuple& t) + { + TuplePrinter::print(t); + std::cout << ", " << std::get(t); + } +}; + +template +struct TuplePrinter { + static void print(const Tuple& t) + { + std::cout << std::get<0>(t); + } +}; + +template +void print(const std::tuple& t) +{ + std::cout << "("; + TuplePrinter::print(t); + std::cout << ")\n"; +} + + int main(int argc, char** argv) { std::cout << "SQLite Proof of Concept Exerciser" << std::endl; + // Make a DBManager instance which will connect to our test DB automagically DBManager db_mgr("database.db"); - db_mgr.test(); - - //~ std::tuple foo{"hello", 120, 3.14}; - //~ db_mgr.func(foo); - //~ visit_at(foo, 1, 18); - - - std::string query("SELECT Number FROM sample;"); - int rc(0); - - - auto results = db_mgr.execute_query>(query, rc); + // Make a query + std::string query("SELECT Number, Float FROM sample;"); + // Execute the query making sure the template params match up with the + // query params + int rc = 0; + auto results = db_mgr.execute_query(query, rc); std::cout << "Return code: " << rc << std::endl; + // If we returned successfully, print out the result rows + if (! rc) + { + uint32_t row_index = 0; + for (auto row : *results) + { + std::cout << "Row: " << std::setw(4) << row_index << " - "; + print(*row); + ++row_index; + } + } + return 0; }