Commit d62ca9f8 authored by louiz’'s avatar louiz’

Use if constexpr to make things a lot more readable

parent ba879a88
...@@ -8,19 +8,16 @@ ...@@ -8,19 +8,16 @@
namespace namespace
{ {
template <std::size_t N=0, typename... T> template <std::size_t N=0, typename... T>
typename std::enable_if<N == sizeof...(T), void>::type void add_column_name(std::string& out)
add_column_name(std::string&)
{ }
template <std::size_t N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type
add_column_name(std::string& out)
{ {
using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<std::tuple<T...>>()))>::type; if constexpr(N < sizeof...(T))
out += ColumnType::name; {
if (N != sizeof...(T) - 1) using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<std::tuple<T...>>()))>::type;
out += ","; out += ColumnType::name;
add_column_name<N+1, T...>(out); if (N != sizeof...(T) - 1)
out += ",";
add_column_name<N + 1, T...>(out);
}
} }
} }
......
...@@ -11,20 +11,17 @@ ...@@ -11,20 +11,17 @@
#include <tuple> #include <tuple>
template <std::size_t N=0, typename... T> template <std::size_t N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void update_autoincrement_id(std::tuple<T...>& columns, Statement& statement)
update_autoincrement_id(std::tuple<T...>& columns, Statement& statement)
{ {
using ColumnType = typename std::decay<decltype(std::get<N>(columns))>::type; if constexpr(N < sizeof...(T))
if (std::is_same<ColumnType, Id>::value) {
auto&& column = std::get<Id>(columns); using ColumnType = typename std::decay<decltype(std::get<N>(columns))>::type;
update_autoincrement_id<N+1>(columns, statement); if (std::is_same<ColumnType, Id>::value)
auto&& column = std::get<Id>(columns);
update_autoincrement_id<N + 1>(columns, statement);
}
} }
template <std::size_t N=0, typename... T>
typename std::enable_if<N == sizeof...(T), void>::type
update_autoincrement_id(std::tuple<T...>&, Statement&)
{}
struct InsertQuery: public Query struct InsertQuery: public Query
{ {
template <typename... T> template <typename... T>
...@@ -53,23 +50,20 @@ struct InsertQuery: public Query ...@@ -53,23 +50,20 @@ struct InsertQuery: public Query
} }
template <int N=0, typename... T> template <int N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
{ {
auto&& column = std::get<N>(columns); if constexpr(N < sizeof...(T))
using ColumnType = std::decay_t<decltype(column)>; {
auto&& column = std::get<N>(columns);
using ColumnType = std::decay_t<decltype(column)>;
if (!std::is_same<ColumnType, Id>::value) if constexpr(!std::is_same<ColumnType, Id>::value)
actual_bind(statement, column.value, index++); actual_bind(statement, column.value, index++);
this->bind_param<N+1>(columns, statement, index); this->bind_param<N + 1>(columns, statement, index);
}
} }
template <int N=0, typename... T>
typename std::enable_if<N == sizeof...(T), void>::type
bind_param(const std::tuple<T...>&, Statement&, int)
{}
template <typename... T> template <typename... T>
void insert_values(const std::tuple<T...>& columns) void insert_values(const std::tuple<T...>& columns)
{ {
...@@ -79,23 +73,21 @@ struct InsertQuery: public Query ...@@ -79,23 +73,21 @@ struct InsertQuery: public Query
} }
template <int N=0, typename... T> template <int N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void insert_value(const std::tuple<T...>& columns, int index=1)
insert_value(const std::tuple<T...>& columns, int index=1)
{ {
using ColumnType = std::decay_t<decltype(std::get<N>(columns))>; if constexpr(N < sizeof...(T))
if (!std::is_same<ColumnType, Id>::value)
{ {
this->body += "$" + std::to_string(index++); using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
if (N != sizeof...(T) - 1)
this->body += ", "; if (!std::is_same<ColumnType, Id>::value)
{
this->body += "$" + std::to_string(index++);
if (N != sizeof...(T) - 1)
this->body += ", ";
}
this->insert_value<N + 1>(columns, index);
} }
this->insert_value<N+1>(columns, index);
} }
template <int N=0, typename... T>
typename std::enable_if<N == sizeof...(T), void>::type
insert_value(const std::tuple<T...>&, const int)
{ }
template <typename... T> template <typename... T>
void insert_col_names(const std::tuple<T...>& columns) void insert_col_names(const std::tuple<T...>& columns)
...@@ -106,24 +98,21 @@ struct InsertQuery: public Query ...@@ -106,24 +98,21 @@ struct InsertQuery: public Query
} }
template <int N=0, typename... T> template <int N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void insert_col_name(const std::tuple<T...>& columns)
insert_col_name(const std::tuple<T...>& columns)
{ {
using ColumnType = std::decay_t<decltype(std::get<N>(columns))>; if constexpr(N < sizeof...(T))
if (!std::is_same<ColumnType, Id>::value)
{ {
this->body += ColumnType::name; using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
if (N < (sizeof...(T) - 1)) if (!std::is_same<ColumnType, Id>::value)
this->body += ", "; {
} this->body += ColumnType::name;
this->insert_col_name<N+1>(columns); if (N < (sizeof...(T) - 1))
} this->body += ", ";
}
template <int N=0, typename... T> this->insert_col_name<N + 1>(columns);
typename std::enable_if<N == sizeof...(T), void>::type }
insert_col_name(const std::tuple<T...>&) }
{}
}; };
...@@ -13,12 +13,12 @@ ...@@ -13,12 +13,12 @@
void actual_bind(Statement& statement, const std::string& value, int index); void actual_bind(Statement& statement, const std::string& value, int index);
void actual_bind(Statement& statement, const std::int64_t& value, int index); void actual_bind(Statement& statement, const std::int64_t& value, int index);
template <typename T, typename std::enable_if_t<std::is_integral<T>::value>* = 0> void actual_bind(Statement& statement, const std::optional<bool>& value, int index);
template <typename T>
void actual_bind(Statement& statement, const T& value, int index) void actual_bind(Statement& statement, const T& value, int index)
{ {
actual_bind(statement, static_cast<std::int64_t>(value), index); actual_bind(statement, static_cast<std::int64_t>(value), index);
} }
void actual_bind(Statement& statement, const std::optional<bool>& value, int index);
#ifdef DEBUG_SQL_QUERIES #ifdef DEBUG_SQL_QUERIES
#include <utils/scopetimer.hpp> #include <utils/scopetimer.hpp>
...@@ -57,38 +57,27 @@ struct Query ...@@ -57,38 +57,27 @@ struct Query
#endif #endif
}; };
template <typename ColumnType> void actual_add_param(Query& query, const std::string& val);
void add_param(Query& query, const ColumnType& column) void actual_add_param(Query& query, const std::optional<bool>& val);
{
std::cout << "add_param<ColumnType>" << std::endl;
actual_add_param(query, column.value);
}
template <typename T> template <typename T>
void actual_add_param(Query& query, const T& val) void actual_add_param(Query& query, const T& val)
{ {
query.params.push_back(std::to_string(val)); query.params.push_back(std::to_string(val));
} }
void actual_add_param(Query& query, const std::string& val);
template <typename T>
typename std::enable_if<!std::is_integral<T>::value, Query&>::type
operator<<(Query& query, const T&)
{
query.body += T::name;
return query;
}
void actual_add_param(Query& query, const std::optional<bool>& val);
Query& operator<<(Query& query, const char* str); Query& operator<<(Query& query, const char* str);
Query& operator<<(Query& query, const std::string& str); Query& operator<<(Query& query, const std::string& str);
template <typename Integer> template <typename T>
typename std::enable_if<std::is_integral<Integer>::value, Query&>::type Query& operator<<(Query& query, const T& i)
operator<<(Query& query, const Integer& i)
{ {
query.body += "$" + std::to_string(query.current_param++); if constexpr(std::is_integral<T>::value)
actual_add_param(query, i); {
query.body += "$" + std::to_string(query.current_param++);
actual_add_param(query, i);
}
else
{
query.body += T::name;
}
return query; return query;
} }
...@@ -29,41 +29,39 @@ struct Row ...@@ -29,41 +29,39 @@ struct Row
return col.value; return col.value;
} }
template <bool Coucou=true> void save(std::unique_ptr<DatabaseEngine>& db)
void save(std::unique_ptr<DatabaseEngine>& db, typename std::enable_if<!is_one_of<Id, T...> && Coucou>::type* = nullptr)
{ {
this->insert(*db); if constexpr(is_one_of<Id, T...>)
}
template <bool Coucou=true>
void save(std::unique_ptr<DatabaseEngine>& db, typename std::enable_if<is_one_of<Id, T...> && Coucou>::type* = nullptr)
{
const Id& id = std::get<Id>(this->columns);
if (id.value == Id::unset_value)
{ {
this->insert(*db); const Id& id = std::get<Id>(this->columns);
if (db->last_inserted_rowid >= 0) if (id.value == Id::unset_value)
std::get<Id>(this->columns).value = static_cast<Id::real_type>(db->last_inserted_rowid); {
this->insert(*db);
if (db->last_inserted_rowid >= 0)
std::get<Id>(this->columns).value = static_cast<Id::real_type>(db->last_inserted_rowid);
}
else
this->update(*db);
} }
else else
this->update(*db); this->insert(*db);
} }
private: private:
template <bool Coucou=true> void insert(DatabaseEngine& db)
void insert(DatabaseEngine& db, typename std::enable_if<is_one_of<Id, T...> && Coucou>::type* = nullptr)
{
InsertQuery query(this->table_name, this->columns);
// Ugly workaround for non portable stuff
query.body += db.get_returning_id_sql_string(Id::name);
query.execute(db, this->columns);
}
template <bool Coucou=true>
void insert(DatabaseEngine& db, typename std::enable_if<!is_one_of<Id, T...> && Coucou>::type* = nullptr)
{ {
InsertQuery query(this->table_name, this->columns); if constexpr(is_one_of<Id, T...>)
query.execute(db, this->columns); {
InsertQuery query(this->table_name, this->columns);
// Ugly workaround for non portable stuff
query.body += db.get_returning_id_sql_string(Id::name);
query.execute(db, this->columns);
}
else
{
InsertQuery query(this->table_name, this->columns);
query.execute(db, this->columns);
}
} }
void update(DatabaseEngine& db) void update(DatabaseEngine& db)
......
...@@ -15,48 +15,37 @@ ...@@ -15,48 +15,37 @@
using namespace std::string_literals; using namespace std::string_literals;
template <typename T> template <typename T>
typename std::enable_if<std::is_integral<T>::value, std::int64_t>::type auto extract_row_value(Statement& statement, const int i)
extract_row_value(Statement& statement, const int i)
{ {
return statement.get_column_int64(i); if constexpr(std::is_integral<T>::value)
} return statement.get_column_int64(i);
else if constexpr (std::is_same<std::string, T>::value)
template <typename T> return statement.get_column_text(i);
typename std::enable_if<std::is_same<std::string, T>::value, T>::type else if (std::is_same<std::optional<bool>, T>::value)
extract_row_value(Statement& statement, const int i) {
{ const auto integer = statement.get_column_int(i);
return statement.get_column_text(i); if (integer > 0)
} return std::optional<bool>{true};
else if (integer < 0)
template <typename T> return std::optional<bool>{false};
typename std::enable_if<std::is_same<std::optional<bool>, T>::value, T>::type return std::optional<bool>{};
extract_row_value(Statement& statement, const int i) }
{
const auto integer = statement.get_column_int(i);
if (integer > 0)
return true;
else if (integer < 0)
return false;
return std::nullopt;
} }
template <std::size_t N=0, typename... T> template <std::size_t N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void extract_row_values(Row<T...>& row, Statement& statement)
extract_row_values(Row<T...>& row, Statement& statement)
{ {
using ColumnType = typename std::remove_reference<decltype(std::get<N>(row.columns))>::type; if constexpr(N < sizeof...(T))
{
using ColumnType = typename std::remove_reference<decltype(std::get<N>(row.columns))>::type;
auto&& column = std::get<N>(row.columns); auto&& column = std::get<N>(row.columns);
column.value = static_cast<decltype(column.value)>(extract_row_value<typename ColumnType::real_type>(statement, N)); column.value = static_cast<decltype(column.value)>(extract_row_value<typename ColumnType::real_type>(statement, N));
extract_row_values<N+1>(row, statement); extract_row_values<N + 1>(row, statement);
}
} }
template <std::size_t N=0, typename... T>
typename std::enable_if<N == sizeof...(T), void>::type
extract_row_values(Row<T...>&, Statement&)
{}
template <typename... T> template <typename... T>
struct SelectQuery: public Query struct SelectQuery: public Query
{ {
...@@ -69,23 +58,21 @@ struct SelectQuery: public Query ...@@ -69,23 +58,21 @@ struct SelectQuery: public Query
} }
template <std::size_t N=0> template <std::size_t N=0>
typename std::enable_if<N < sizeof...(T), void>::type void insert_col_name()
insert_col_name()
{ {
using ColumnsType = std::tuple<T...>; if constexpr(N < sizeof...(T))
using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnsType>()))>::type; {
using ColumnsType = std::tuple<T...>;
using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnsType>()))>::type;
this->body += " " + std::string{ColumnType::name}; this->body += " " + std::string{ColumnType::name};
if (N < (sizeof...(T) - 1)) if (N < (sizeof...(T) - 1))
this->body += ", "; this->body += ", ";
this->insert_col_name<N+1>(); this->insert_col_name<N + 1>();
}
} }
template <std::size_t N=0>
typename std::enable_if<N == sizeof...(T), void>::type
insert_col_name()
{}
SelectQuery& where() SelectQuery& where()
{ {
......
...@@ -93,36 +93,32 @@ class Table ...@@ -93,36 +93,32 @@ class Table
private: private:
template <std::size_t N=0> template <std::size_t N=0>
typename std::enable_if<N < sizeof...(T), void>::type void add_column_if_not_exists(DatabaseEngine& db, const std::set<std::string>& existing_columns)
add_column_if_not_exists(DatabaseEngine& db, const std::set<std::string>& existing_columns)
{ {
using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type; if constexpr(N < sizeof...(T))
if (existing_columns.count(ColumnType::name) == 0) {
add_column_to_table<ColumnType>(db, this->name); using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type;
add_column_if_not_exists<N+1>(db, existing_columns); if (existing_columns.count(ColumnType::name) == 0)
add_column_to_table<ColumnType>(db, this->name);
add_column_if_not_exists<N + 1>(db, existing_columns);
}
} }
template <std::size_t N=0>
typename std::enable_if<N == sizeof...(T), void>::type
add_column_if_not_exists(DatabaseEngine&, const std::set<std::string>&)
{}
template <std::size_t N=0> template <std::size_t N=0>
typename std::enable_if<N < sizeof...(T), void>::type void add_column_create(DatabaseEngine& db, std::string& str)
add_column_create(DatabaseEngine& db, std::string& str)
{ {
using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type; if constexpr(N < sizeof...(T))
str += ColumnType::name; {
str += " "; using ColumnType = typename std::remove_reference<decltype(std::get<N>(std::declval<ColumnTypes>()))>::type;
str += ToSQLType<ColumnType>(db); str += ColumnType::name;
if (N != sizeof...(T) - 1) str += " ";
str += ","; str += ToSQLType<ColumnType>(db);
if (N != sizeof...(T) - 1)
add_column_create<N+1>(db, str); str += ",";
add_column_create<N + 1>(db, str);
}
} }
template <std::size_t N=0>
typename std::enable_if<N == sizeof...(T), void>::type
add_column_create(DatabaseEngine&, std::string&)
{ }
const std::string name; const std::string name;
}; };
...@@ -39,27 +39,25 @@ struct UpdateQuery: public Query ...@@ -39,27 +39,25 @@ struct UpdateQuery: public Query
} }
template <int N=0, typename... T> template <int N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void insert_col_name_and_value(const std::tuple<T...>& columns)
insert_col_name_and_value(const std::tuple<T...>& columns)
{ {
using ColumnType = std::decay_t<decltype(std::get<N>(columns))>; if constexpr(N < sizeof...(T))
if (!std::is_same<ColumnType, Id>::value)
{ {
this->body += ColumnType::name + "=$"s + std::to_string(this->current_param); using ColumnType = std::decay_t<decltype(std::get<N>(columns))>;
this->current_param++;
if (N < (sizeof...(T) - 1)) if (!std::is_same<ColumnType, Id>::value)
this->body += ", "; {
} this->body += ColumnType::name + "=$"s
+ std::to_string(this->current_param);
this->current_param++;
this->insert_col_name_and_value<N+1>(columns); if (N < (sizeof...(T) - 1))
} this->body += ", ";
template <int N=0, typename... T> }
typename std::enable_if<N == sizeof...(T), void>::type
insert_col_name_and_value(const std::tuple<T...>&)
{}
this->insert_col_name_and_value<N + 1>(columns);
}
}
template <typename... T> template <typename... T>
void execute(DatabaseEngine& db, const std::tuple<T...>& columns) void execute(DatabaseEngine& db, const std::tuple<T...>& columns)
...@@ -76,23 +74,20 @@ struct UpdateQuery: public Query ...@@ -76,23 +74,20 @@ struct UpdateQuery: public Query
} }
template <int N=0, typename... T> template <int N=0, typename... T>
typename std::enable_if<N < sizeof...(T), void>::type void bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
bind_param(const std::tuple<T...>& columns, Statement& statement, int index=1)
{ {
auto&& column = std::get<N>(columns); if constexpr(N < sizeof...(T))
using ColumnType = std::decay_t<decltype(column)>; {
auto&& column = std::get<N>(columns);
using ColumnType = std::decay_t<decltype(column)>;
if (!std::is_same<ColumnType, Id>::value) if (!std::is_same<ColumnType, Id>::value)
actual_bind(statement, column.value, index++); actual_bind(statement, column.value, index++);
this->bind_param