Use Variadic templates (or a similar mechanism) to pass list of types to a function

Question

I would like to implement a class wrapper for database.
Currently, I'm working on a createTable function.
The way I have tried to make it work is, that the user specifies the types
as a template parameters, and the column names as an initialiser list, this is the template of the function:

template <typename ... Ts>
bool createTable(const std::string & tableName, const std::initializer_list<std::string> & columnNames);

And this is the body of the method:

template<typename ... Ts>
bool DatabaseConnection::createTable(const std::string &tableName, const std::initializer_list<std::string> & columnNames)
{
    constexpr size_t num_cols = sizeof...(Ts);

    assert(num_cols == columnNames.size());
    auto typetuple = std::tuple<Ts...>();

    std::vector<std::tuple<std::string, std::string>> columnNameAndType(num_cols);

    auto columnNameIterator = columnNames.begin();


    for(unsigned it = 0; it++ < columnNames.size(); it++){
        typedef std::tuple_element<it, typetuple>::type c; // non-type template argument is not a constant expression
        if(is_same<c, int> ...) //pseudocode
            std::string dbtype = "INTEGER"; //pseudocode

    }

}

Sadly, the tuple_element line doesn't work, because it's not really a constant expression. Now, someone might ask, why I want to call it like this: createTable<int, std::string>("Users", {"ID", "Name"}); instead of just passing two initialiser lists?

Well I just want to distance the user from the interface - If I were able to determine the it-h type I could just use something like decltype or is_same to determine the type used in database creation query - the user just says what type he/she wants and the Database class determines the best database type to match the user's request.

Now, it could still be made with initaliser lists, but it wouldn't be compile time, and I'm just curious to see if it's possible at comple time.

I hope my explanation of the problem is sufficient.
Of course this is mostly a theoretical problem, but I think many people would be interested in such a syntax, and I haven't found any solutions on the internet yet.

Answer 1

This interface is certainly possible.

A for loop isn't going to do it, because one statement/variable/expression/etc. can't have different types on different evaluations of a for substatement. The loop will need to be via pack expansion instead.

One or more private helper member functions could help for this. It would be possible to get it all in one function definition using a generic lambda, but a little unpleasant.

// private static
template <typename T>
std::string DatabaseConnection::dbTypeName()
{
    if constexpr (std::is_same_v<T, int>)
        return "INTEGER";
    // ...
    else
        static_assert(!std::is_same_v<T,T>, "Unsupported type argument");
}

template<typename ... Ts>
bool DatabaseConnection::createTable(
    const std::string &tableName,
    std::initializer_list<std::string> columnNames)
{
    constexpr size_t num_cols = sizeof...(Ts);

    assert(num_cols == columnNames.size());

    std::vector<std::tuple<std::string, std::string>> columnNameAndType;

    auto columnNameIterator = columnNames.begin();

    (columnNameAndType.emplace_back(*columnNameIterator++, dbTypeName<Ts>()), ...);

    // ...    
}