我正在开发一个处理非类型化 C 函数 (SQLite) 的库，我想对其进行强类型化处理。

想法是拥有一个 FieldDef 强类型，允许用户将原始类型(如 int、double 和 std::string)绑定(bind)到弱数据库类型。 我的问题是库的语义很重，我想添加一些自动类型推导。

所以我有一堆“基本类型”:

namespace FieldType {
  struct Integer { using rawtype = int; };
  struct Real{ using rawtype = double; };
  struct Text{ using rawtype = std::string; };
  struct Blob{ using rawtype = std::vector<uint8_t>; };
}

我还有一个insert 和一个query 函数，它们允许在不使用SQL 语句的情况下插入和查询表。查询将是简单的选择。反正。预期用途是:

FieldDef<FieldType::Integer> mId = makeFieldDef("id", FieldType::Integer()).primaryKey().autoincrement();
FieldDef<FieldType::Text> mName = makeFieldDef("name", FieldType::Text());
FieldDef<FieldType::Integer> mValue = makeFieldDef("value", FieldType::Integer());

SQLiteTable::insert(std::make_tuple(mName, mValue), std::make_tuple(record.name, record.value));

std::vector<Record> r;
SQLiteTable::query
            (std::make_tuple(mName, mValue), [&r](std::tuple<std::string, int> res) {
        r.push_back(Record{std::get<0>(res), std::get<1>(res)});
});

我是这样实现插入的:

template <typename ...Ts, typename ...Us>
bool insert (std::tuple<Ts...> def, std::tuple<Us...> values) {
    std::ostringstream ss;
    ss << "INSERT INTO " << mName << "("
                                  << buildSqlInsertFieldList<0>(def)
                                  << ") VALUES ("
                                  << buildSqlInsertValuesListPlaceholder<0>(values)
                                  << ");";
    auto stmt = newStatement(ss.str());
    bindAllValues<0>(stmt.get(), values);
    return execute(stmt.get());
}

这工作正常，问题来自查询:

template <typename ...Ts, typename ...Us>
void query(std::tuple<Ts...> def, std::function<void(std::tuple<Us...>)> resultFeedbackFunc) {
   ...
}

当调用它时，编译器无法正确推导类型，所以我猜它需要一个迂腐的构造:

SQLiteTable::query<FieldType::Text, FieldType::Integer, /* whatever */> (...)

这是不切实际和冗长的。

1. 可否简化查询功能？ 由于我们在使用上有一个限制，即 Us 包只能是与 FieldType::*:rawtype 兼容的某种类型，我想问一下这是否可能使用一些解包和应用方法的构造。在 insert 的情况下，是否可以简化为:

   template<typename Ts...>
   bool insert (std::tuple<Ts...> def, std::tuple<Ts::rawtype ...> values) 
   

2. 不使用元组，使用可变参数包怎么样？我还没有测试过，但我担心使用类似的东西

   template<typename Ts..., typename Us....>
   bool insert (Ts... def, Us ... values) 
   

会混淆编译器并使事情变得更糟。 你怎么看？

1. 如果可以使用查询的实际实现，有什么变通方法可以使使用代码更具表现力？

下面是一些关于代码的细节，解释一下:

查询功能使用以下伪代码实现:

template <typename ...Ts, typename ...Us>
void query(std::tuple<Ts...> def, std::function<void(std::tuple<Us...>)> resultFeedbackFunc) {
    std::ostringstream ss;
    ss << "SELECT " << buildSqlInsertFieldList<0>(def) << " FROM " << mName <<";";
    auto stmt = newStatement(ss.str());

    auto r = execute(stmt.get());
    SQLiteException::throwIfNotOk(r, db()->handle());

    while (hasData(stmt.get())) {
        auto nColumns = columnCount(stmt.get());
        if (nColumns != sizeof...(Ts))
            throw std::runtime_error("Column count differs from data size");

        std::tuple<Us...> res;
        getAllValues<0>(stmt.get(), res);
        resultFeedbackFunc(res);
    }
};

Statement 是一个不透明类型，它隐藏了 sqlite 语句结构，query 方法 newStatement 中使用的其他函数也是如此、执行 和columnsCount。函数 getAllValues 使用递归来填充 tuple。因此，将为数据库的每一行调用仿函数 resultFeedbackFunc()。例如，客户端代码可以填充容器(如 vector )。

更新:

我遵循了@bolov 的解决方案，并添加了@massimiliano-jones 的改进。

这是内部调用反馈函数的正确实现:

resultFeedbackFunc(getValueR<decltype (std::get<Is>(def).rawType())>
      (stmt.get(), Is)...);

getValueR 对 sqlite_column_xxx(sqlite3_stmt *, int index) 进行内部调用。如果我理解正确的话，解包是有效的，因为参数列表是解包的有效上下文。如果我想在参数之外进行调用，我必须进行折叠(或解决方法，因为我使用的是 c++11)。

最佳答案

很难提供具体的帮助，因为您的帖子中缺少重要的代码部分。

但是这是我的 2 美分。请注意，我已经用我的想象力填补了您代码中缺失的部分。

首先你需要去掉 std::function争论。使用 std::function仅当您需要它提供的类型删除时。在您的情况下(至少从您显示的代码来看)您不需要它。所以我们用一个简单的 template <class F> 代替它范围。这解决了演绎问题。

现在，当您传递一个无效的函数对象时，您将在 query 的碗深处得到一个编译错误。执行。如果您不想那样，并且想快速失败，那么有一些选择。我选择用 decltype 向您展示 SFINAE 方法.

namespace FieldType
{
  struct Integer { using rawtype = int; };
  struct Real{ using rawtype = double; };
  struct Text{ using rawtype = std::string; };
};

template <class FT>
struct FieldDef
{
    using Type = FT;
    using RawTye = typename Type::rawtype;

    auto getRaw() -> RawTye { return {}; }
};

template <class... Args, class F, std::size_t... Is>
auto query_impl(std::tuple<Args...> def, F f, std::index_sequence<Is...>)
    -> decltype(f(std::get<Is>(def).getRaw()...), std::declval<void>())
{
   f(std::get<Is>(def).getRaw()...);
}

template <class... Args, class F>
auto query(std::tuple<Args...> def, F f)
    -> decltype(query_impl(def, f, std::make_index_sequence<sizeof...(Args)>{}))
{
   query_impl(def, f, std::make_index_sequence<sizeof...(Args)>{});
}

auto test()
{
    FieldDef<FieldType::Text> mName = {};
    FieldDef<FieldType::Integer> mValue = {};

    query(std::make_tuple(mName, mValue), [](std::string, int) {});      // OK

    query(std::make_tuple(mName, mValue), [](std::string, int, int) {}); // Error
    query(std::make_tuple(mName, mValue), [](int, int) {});              // Error
}

无效调用失败并显示类似于以下内容的消息:

error: no matching function for call to 'query'
...   
note: candidate template ignored: substitution failure [with Args = ...]:
  no matching function for call to 'query_impl'
...

关于您的第 2 点。那是不可扣除的。即使是这样，您也希望对参数进行分组以提高可读性。 IE。你想要insert({a, b}, {c, d})而不是 insert(a, b, c, d) .

我不明白你的第 3 点。

关于使用推导的 C++ 可变参数扩展，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47326863/