Project

General

Profile

« Previous | Next » 

Revision 6e4119a4

Added by David Sorber over 9 years ago

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.

View differences:

software/sqlite_poc/DBManager.h
#include <sqlite3.h>
template <size_t I>
struct visit_impl
template<size_t I>
struct builder_impl
{
template <typename T, typename V>
static void visit(T& tup, size_t idx, V value)
template<typename T, typename G>
static void set_value(T& tup, size_t idx, G& val)
{
if (idx == I - 1)
if (idx == I - 1)
{
if (std::is_same<std::get<I - 1>(tup), value>)
{
std::get<I - 1>(tup) = value;
}
else
{
assert(false);
}
std::get<I - 1>(tup) = val;
}
else
{
visit_impl<I - 1>::visit(tup, idx, value);
builder_impl<I - 1>::set_value(tup, idx, val);
}
}
};
template <>
struct visit_impl<0>
struct builder_impl<0>
{
template <typename T, typename V>
static void visit(T& tup, size_t idx, V fun) { assert(false); }
template<typename T, typename G>
static void set_value(T& tup, size_t idx, G& val)
{
assert(false);
}
};
template <typename G, typename... Ts>
void set_value_at(std::tuple<Ts...>& tup, size_t idx, G const& val)
{
builder_impl<sizeof...(Ts)>::set_value(tup, idx, val);
}
//~ template <typename V, typename... Ts>
//~ void visit_at(std::tuple<Ts...> const& tup, size_t idx, V value)
//~ {
//~ visit_impl<sizeof...(Ts)>::visit(tup, idx, value);
//~ }
template <typename V, typename... Ts>
void visit_at(std::tuple<Ts...>& tup, size_t idx, V value)
template <typename G, typename... Ts>
void set_value_at(std::tuple<Ts...>& tup, size_t idx, G& val)
{
visit_impl<sizeof...(Ts)>::visit(tup, idx, value);
builder_impl<sizeof...(Ts)>::set_value(tup, idx, val);
}
class DBManager
{
public:
......
~DBManager();
// execute query
template<typename T>
std::vector<T*>* execute_query(
template<typename... T>
std::vector<std::tuple<T...>*>* execute_query(
const std::string& sql_statement,
int& return_code)
{
......
return nullptr;
}
auto output_vector = new std::vector<T*>();
int step_return = 0;
auto output_vector = new std::vector<std::tuple<T...>*>();
// 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<T...>();
// Iterate over the columns in the row
int num_cols = sqlite3_data_count(sqlite_statement);
......
{
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<col_idx>(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<col_idx>(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<const char*>(sqlite3_column_text(sqlite_statement, col_idx))));
//~ std::get<col_idx>(result_row) =
//~ std::string(sqlite3_column_text(sqlite_statement, col_idx));
//~ set_value_at(*result_row, col_idx,
//~ std::string(reinterpret_cast<const char*>(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<typename T>
std::vector<T> func(T& foo)
{
std::cout << "Does this work??? " << std::get<2>(foo) << std::endl;
std::vector<T> bar;
bar.push_back(foo);
return bar;
}
private:
sqlite3 *db;
uint32_t numba;
};

Also available in: Unified diff