database/types.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_DATABASE_TYPES_H
#define __SSRC_WSPR_DATABASE_TYPES_H

// This is actually the maximum number of parameters + 1
// (e.g., specify 10 parameters with a value of 11).
#define WSPR_DB_MAX_PARAMETERS 21

#include <ssrc/wispers/utility/CTypeWrapper.h>
#include <ssrc/wisp/utility/wisp_struct.h>

#include <boost/preprocessor/repetition.hpp>
#include <cstdint>
#include <climits>

#include <string>
#include <stdexcept>

__BEGIN_NS_SQLITE3_INCLUDE
#include <sqlite3.h>
__END_NS_SQLITE3_INCLUDE

__BEGIN_NS_SSRC_WSPR_DATABASE

using std::string;
using NS_SSRC_WSPR_UTILITY::CTypeWrapper;
// We need this for SQLITE_STATIC and SQLITE_TRANSIENT macros to work.
using SQLite3::sqlite3_destructor_type;

namespace detail {

  struct sqlite3_init {
    int operator()(SQLite3::sqlite3 **p, const string & db_name = ":memory:")
      const
    {
      return SQLite3::sqlite3_open(db_name.c_str(), p);
    }
  };

  struct sqlite3_delete;

  typedef
  CTypeWrapper<SQLite3::sqlite3, int, sqlite3_init, sqlite3_delete>
  sqlite3_ptr;

  struct sqlite3_stmt_initializer {
    sqlite3_ptr & database;
    const string & statement;

    sqlite3_stmt_initializer(sqlite3_ptr & database,
                             const string & statement) :
      database(database), statement(statement)
    { }
  };

  struct sqlite3_stmt_init {
    int operator()(SQLite3::sqlite3_stmt **p) const {
      return SQLITE_ERROR;
    }
    int operator()(SQLite3::sqlite3_stmt **p,
                   sqlite3_stmt_initializer initializer)
      const
    {
      const char *tail;
      return
        SQLite3::sqlite3_prepare_v2(initializer.database.get(),
                                    initializer.statement.c_str(),
                                    initializer.statement.size(),
                                    p, &tail);
    }
  };

  struct sqlite3_stmt_delete {
    void operator()(SQLite3::sqlite3_stmt *p) const {
      if(p)
        SQLite3::sqlite3_finalize(p);
    }
  };

  typedef
  CTypeWrapper<SQLite3::sqlite3_stmt, int,
               sqlite3_stmt_init, sqlite3_stmt_delete>
  sqlite3_stmt_ptr;
}

using detail::sqlite3_ptr;
using detail::sqlite3_stmt_ptr;

class DatabaseException : public std::runtime_error {
  typedef std::runtime_error super;

  bool _statement_reset;

public:
  explicit DatabaseException(const string & message) :
    super(message), _statement_reset(false)
  { }

  explicit DatabaseException(SQLite3::sqlite3 *db) :
    super(SQLite3::sqlite3_errmsg(db)), _statement_reset(false)
  { }

  explicit DatabaseException(const sqlite3_ptr & db) :
    super(SQLite3::sqlite3_errmsg(db.get())), _statement_reset(false)
  { }

  explicit DatabaseException(const sqlite3_stmt_ptr & stmt) :
    super(string(SQLite3::sqlite3_errmsg(SQLite3::sqlite3_db_handle(stmt.get()))).append(":\n").append(SQLite3::sqlite3_sql(stmt.get()))),
    _statement_reset((SQLite3::sqlite3_reset(stmt.get()) == SQLITE_OK))
  { }

  bool statement_reset() const { return _statement_reset; }
};

namespace detail {

  struct sqlite3_delete {
    void operator()(SQLite3::sqlite3 *p) const {
      // We violate the boost::shared_ptr contract by throwing, but what
      // else can we do...
      if(p && SQLite3::sqlite3_close(p) != SQLITE_OK)
        throw DatabaseException(p);
    }
  };

  inline int step(const sqlite3_stmt_ptr & statement)
    SSRC_DECL_THROW(DatabaseException)
  {
    int result = SQLite3::sqlite3_step(statement.get());

    if(result == SQLITE_DONE) {
      if(SQLite3::sqlite3_reset(statement.get()) != SQLITE_OK)
        throw DatabaseException(statement);
    }

    return result;
  }

  template<typename T, int elements> struct Values;
}

// IMPORTANT: Leave second member as non-const.  Also, note that
// first member is pointer to a const, not a const in itself.
// This is so we can reuse a blob_type in a loop.
typedef std::pair<const void *, unsigned int> blob_type;

// Forward declaration.
class ResultSet;
template<typename T> inline T value(const ResultSet & result_set,
                                    const unsigned int index);
template<typename T> inline T values(const ResultSet & result_set);

class ResultSet {
  friend class PreparedStatement;

  bool _done;
  unsigned int _row_number;
  sqlite3_stmt_ptr _statement;

  explicit
  ResultSet(const sqlite3_stmt_ptr & statement) :
    _done(false), _row_number(0), _statement(statement)
  { }

public:

  enum ColumnType {
    Integer = SQLITE_INTEGER,
    Float   = SQLITE_FLOAT,
    Text    = SQLITE_TEXT,
    Blob    = SQLITE_BLOB,
    Null    = SQLITE_NULL
  };

  unsigned int count_values() const {
    return SQLite3::sqlite3_data_count(_statement.get());
  }

  bool done() const { return _done; }

  unsigned int row_number() const { return _row_number; }

  bool next() SSRC_DECL_THROW(DatabaseException) {
    int result = detail::step(_statement);

    if(result == SQLITE_DONE || result == SQLITE_MISUSE) {
      _done = true;
      ++_row_number;
    } else if(result != SQLITE_ROW) {
      _done = true;
      throw DatabaseException(_statement);
    } else
      ++_row_number;

    return !_done;
  }

  ColumnType column_type(const unsigned int index) const {
    return
      static_cast<ColumnType>(SQLite3::sqlite3_column_type(_statement.get(), index));
  }

  template<typename T> inline T value(unsigned int index = 0) const {
    return NS_SSRC_WSPR_DATABASE::value<T>(*this, index);
  }

  template<typename T> T values() const {
    return NS_SSRC_WSPR_DATABASE::values<T>(*this);
  }

#define WSPR_DB_VALUES_ARG(z, i, _) BOOST_PP_COMMA_IF(i) value<V ## i>(i)

#define WSPR_DB_VALUES(z, i, _)                                          \
  template<BOOST_PP_ENUM_PARAMS(i, typename V)>                         \
  std::tuple<BOOST_PP_ENUM_PARAMS(i, V)> values() const {     \
    return std::make_tuple<BOOST_PP_ENUM_PARAMS(i, V)>(BOOST_PP_REPEAT(i, WSPR_DB_VALUES_ARG, _)); \
  }

BOOST_PP_REPEAT_FROM_TO(2, WSPR_DB_MAX_PARAMETERS, WSPR_DB_VALUES, _)

#undef WSPR_DB_VALUES
#undef WSPR_DB_VALUES_ARG

  template<typename T> operator T() const {
    return values<T>();
  }

  // Returns the number of iterations.
  template<typename functor>
  unsigned int for_each(const functor & apply)
    SSRC_DECL_THROW(DatabaseException)
  {
    unsigned int starting_row(_row_number);

    while(!done()) {
      apply(*this);
      next();
    }

    return (_row_number - starting_row);
  }

};

template<> inline string ResultSet::value<string>(unsigned int index) const
  SSRC_DECL_THROW(DatabaseException)
{
  const unsigned char* result =
    SQLite3::sqlite3_column_text(_statement.get(), index);

  if(!result)
    throw DatabaseException(_statement);

  return string(reinterpret_cast<char*>(const_cast<unsigned char*>(result)));
}

template<> inline int ResultSet::value<int>(unsigned int index) const {
  return SQLite3::sqlite3_column_int(_statement.get(), index);
}

template<> inline
unsigned int ResultSet::value<unsigned int>(unsigned int index) const {
  return value<int>(index);
}

template<> inline
std::int16_t ResultSet::value<std::int16_t>(unsigned int index) const {
  return value<int>(index);
}

template<> inline
std::uint16_t ResultSet::value<std::uint16_t>(unsigned int index) const {
  return value<int>(index);
}

template<> inline bool ResultSet::value<bool>(unsigned int index) const {
  return value<int>(index);
}

template<> inline
std::int64_t ResultSet::value<std::int64_t>(unsigned int index) const {
  return SQLite3::sqlite3_column_int64(_statement.get(), index);
}

template<> inline
std::uint64_t ResultSet::value<std::uint64_t>(unsigned int index) const {
  return static_cast<std::uint64_t>(value<std::int64_t>(index));
}

#if (LONG_MAX == INT_MAX)
template<> inline long ResultSet::value<long>(unsigned int index) const {
  return static_cast<long>(value<std::int64_t>(index));
}

template<>
inline unsigned long ResultSet::value<unsigned long>(unsigned int index) const {
  return static_cast<unsigned long>(value<std::int64_t>(index));
}
#endif

template<> inline double ResultSet::value<double>(unsigned int index) const {
  return SQLite3::sqlite3_column_double(_statement.get(), index);
}

template<> inline
const void * ResultSet::value<const void *>(unsigned int index) const {
  return SQLite3::sqlite3_column_blob(_statement.get(), index);
}

template<> inline
blob_type ResultSet::value<blob_type>(unsigned int index) const {
  return
    blob_type(value<const void *>(index),
              SQLite3::sqlite3_column_bytes(_statement.get(), index));
}

namespace detail {
  using std::tuple_element;

#define WSPR_DB_VALUES_ARG(z, i, _) \
  BOOST_PP_COMMA_IF(i) typename tuple_element<i,T>::type

#define WSPR_DB_VALUES(z, i, _)                                          \
  template<typename T> struct Values<T, i> {                            \
    static T values(const ResultSet & result_set) {                     \
      return result_set.values<BOOST_PP_REPEAT(i, WSPR_DB_VALUES_ARG, _)>(); \
    }                                                                   \
  };

BOOST_PP_REPEAT_FROM_TO(2, WSPR_DB_MAX_PARAMETERS, WSPR_DB_VALUES, _)

#undef WSPR_DB_VALUES
#undef WSPR_DB_VALUES_ARG
}

// You can specialize this function to create your own result_set conversions.
// The general function converts variable-length tuples.
template<typename T> inline T values(const ResultSet & result_set) {
  return
    detail::Values<T, std::tuple_size<T>::value>::values(result_set);
}

template<> inline string values<string>(const ResultSet & result_set) {
  return result_set.value<string>();
}

template<> inline int values<int>(const ResultSet & result_set) {
  return result_set.value<int>();
}

template<> inline
unsigned int values<unsigned int>(const ResultSet & result_set) {
  return result_set.value<unsigned int>();
}

template<> inline
std::int16_t values<std::int16_t>(const ResultSet & result_set) {
  return result_set.value<std::int16_t>();
}

template<> inline
std::uint16_t values<std::uint16_t>(const ResultSet & result_set) {
  return result_set.value<std::uint16_t>();
}

template<> inline bool values<bool>(const ResultSet & result_set) {
  return result_set.value<bool>();
}

template<>
inline std::int64_t values<std::int64_t>(const ResultSet & result_set) {
  return result_set.value<std::int64_t>();
}

template<>
inline std::uint64_t values<std::uint64_t>(const ResultSet & result_set) {
  return result_set.value<std::uint64_t>();
}

#if (LONG_MAX == INT_MAX)
template<> inline long values<long>(const ResultSet & result_set) {
  return result_set.value<long>();
}

template<>
inline unsigned long values<unsigned long>(const ResultSet & result_set) {
  return result_set.value<unsigned long>();
}
#endif

template<> inline double values<double>(const ResultSet & result_set) {
  return result_set.value<double>();
}

template<>
inline blob_type values<blob_type>(const ResultSet & result_set) {
  return result_set.value<blob_type>();
}

typedef boost::shared_ptr<ResultSet> result_set_ptr;

namespace detail {

  template<typename T>
  struct is_basic_type {
    static const bool value = false;
  };

#if (LONG_MAX == INT_MAX)
#  define __BASIC_TYPES \
     (std::string)(int)(unsigned int)(std::int16_t)(std::uint16_t)(bool)(std::int64_t)(std::uint64_t)(long)(unsigned long)(double)(blob_type)
#else
#  define __BASIC_TYPES \
     (std::string)(int)(unsigned int)(std::int16_t)(std::uint16_t)(bool)(std::int64_t)(std::uint64_t)(double)(blob_type)
#endif

#define __IS_BASIC(r, data, type)    \
  template<> struct is_basic_type<type> { \
    static const bool value = true;  \
  };

  BOOST_PP_SEQ_FOR_EACH(__IS_BASIC, _, __BASIC_TYPES)

#undef __IS_BASIC

#undef __BASIC_TYPES

  template<typename T, bool is_basic> struct ResultSetValueTraits;

  template<typename T>
  struct ResultSetValueTraits<T, true> {
    typedef T type;
    typedef T db_value_type;
  };

  template<typename T>
  struct ResultSetValueTraits<T, false> {
    typedef T type;
    typedef typename T::db_value_type db_value_type;
  };
}

#define __WSPR_DB_INIT_RESULT_SET(r, rs, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, arg)(std::move(rs.value<NS_SSRC_WSPR_DATABASE::detail::ResultSetValueTraits<BOOST_PP_TUPLE_ELEM(2, 0, arg), NS_SSRC_WSPR_DATABASE::detail::is_basic_type<BOOST_PP_TUPLE_ELEM(2, 0, arg)>::value >::db_value_type>(i)))

#define __WSPR_DB_BIND_ROW(r, data, i, arg)              \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, arg)

#define __WSPR_DB_LOAD_ROW __WSPR_DB_BIND_ROW

#define __WSPR_DB_ROW_ELEMENT(r, name, i, arg)                          \
  template<> struct name::Element<i> {                                  \
    typedef BOOST_PP_TUPLE_ELEM(2, 0, arg) type;                        \
  };                                                                    \
  template<> inline const name::Element<i>::type & name::get<i>() const { \
    return BOOST_PP_TUPLE_ELEM(2, 1, arg);                              \
  }                                                                     \
  template<> inline std::string name::column_name<i>() {        \
    return BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 1, arg));          \
  }

#define __WSPR_DB_ROW_KEY(r, name, i, arg)                              \
  template<> struct name::Key<i> {                                      \
    static const unsigned int column = arg;                             \
  };

#define __WSPR_DB_ROW_IS_PRIMARY_KEY_CONDITION(r, column, i, arg)        \
  BOOST_PP_EXPR_IF(i, ||) (column == arg)

#define __WSPR_DB_ROW_IS_PRIMARY_KEY(r, name, arg)            \
  template<> inline bool name::is_primary_key<arg>() { return true; }

#define __WSPR_DB_RETURN_COLUMN_NAME(r, data, i, arg)                    \
  case i: return BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 1, arg)); break;

#define __WSPR_DB_ROW_PRIMARY_KEY_ELEMENT_TYPES(r, member_sequence, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_ELEM(arg, member_sequence))

#define __WSPR_DB_ROW_PRIMARY_KEY_ELEMENT_REF_TYPES(r, member_sequence, i, arg) \
  BOOST_PP_COMMA_IF(i) const BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_ELEM(arg, member_sequence))&

#define __WSPR_DB_ROW_PRIMARY_KEY_TYPE(member_sequence, key_sequence)    \
  BOOST_PP_IIF(BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(key_sequence)),       \
               BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_ELEM(BOOST_PP_SEQ_ELEM(0, key_sequence), member_sequence)), primary_key_tuple_type)

#define __WSPR_DB_ROW_PRIMARY_KEY_REF_TYPE(member_sequence, key_sequence)    \
  BOOST_PP_IIF(BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(key_sequence)),       \
               const BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_SEQ_ELEM(BOOST_PP_SEQ_ELEM(0, key_sequence), member_sequence))&, primary_key_tie_type)

#define __WSPR_DB_ROW_PRIMARY_KEY_ELEMENTS(r, member_sequence, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_ELEM(arg, member_sequence))

#define __WSPR_DB_ROW_PRIMARY_KEY_BIND_PARAM(z, i, key) \
  BOOST_PP_COMMA_IF(i) std::get<i>(key)

#define __WSPR_DB_ROW_PRIMARY_KEY_BIND_PARAM_OFFSET(z, i, key) \
  .bind(offset + i + 1, std::get<i>(key))

#define __WSPR_DB_ROW_CONST_UINT(z, i, _) \
  BOOST_PP_COMMA_IF(i) const unsigned int

#define __WSPR_DB_ROW_PRIMARY_KEY_INDEX(z, _, i, arg) \
  BOOST_PP_COMMA_IF(i) arg

#define __WSPR_DB_ROW_WITH_KEY(name, member_sequence, key_sequence)     \
  struct name : public NS_SSRC_WISP_UTILITY::wisp_struct {              \
    enum { ElementCount = BOOST_PP_SEQ_SIZE(member_sequence) };         \
    enum { PrimaryKeyCount = BOOST_PP_SEQ_SIZE(key_sequence) };         \
    static inline std::string table_name() {return BOOST_PP_STRINGIZE(name);} \
    static inline std::string column_name(const unsigned int column) {  \
      switch(column) {                                                  \
        BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_RETURN_COLUMN_NAME, _, member_sequence) \
      };                                                                \
      return std::string();                                             \
    }                                                                   \
    static inline bool is_primary_key(unsigned int column) {     \
      return ( BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_IS_PRIMARY_KEY_CONDITION, column, key_sequence) ); \
    }                                                                   \
    typedef std::tuple<BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(key_sequence), __WSPR_DB_ROW_CONST_UINT, _)> primary_key_columns_type; \
    static inline primary_key_columns_type primary_key_columns() { \
    return primary_key_columns_type(BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_PRIMARY_KEY_INDEX, _, key_sequence)); \
    } \
    __WISP_STRUCT(0, name, member_sequence)                              \
    name(const NS_SSRC_WSPR_DATABASE::ResultSet & result) :              \
      BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_INIT_RESULT_SET, result, member_sequence) { } \
    template<class Binder>                                              \
    void bind_row(Binder & binder) const SSRC_DECL_THROW(NS_SSRC_WSPR_DATABASE::DatabaseException) { \
      binder.bindp(BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_BIND_ROW, _, member_sequence)); \
    }                                                                   \
    template<class Loader, const unsigned int offset = 0>               \
    void load_row(const NS_SSRC_WSPR_DATABASE::ResultSet & result,      \
                  Loader & loader)                                      \
      SSRC_DECL_THROW(NS_SSRC_WSPR_DATABASE::DatabaseException)         \
    {                                                                   \
      loader.template loadp<offset>(result, BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_LOAD_ROW, _, member_sequence)); \
    }                                                                   \
    template<unsigned int i> struct Element;                            \
    template<unsigned int i> struct Key;                                \
    template<unsigned int i> inline                                     \
    const typename name::template Element<i>::type & get() const;       \
    template<unsigned int i> inline static std::string column_name();   \
    template<unsigned int i> inline static bool is_primary_key() {      \
      return false;                                                     \
    }                                                                   \
    typedef std::tuple<BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_PRIMARY_KEY_ELEMENT_TYPES, member_sequence, key_sequence)> primary_key_tuple_type; \
    typedef std::tuple<BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_PRIMARY_KEY_ELEMENT_REF_TYPES, member_sequence, key_sequence)> primary_key_tie_type; \
    typedef __WSPR_DB_ROW_PRIMARY_KEY_TYPE(member_sequence, key_sequence) primary_key_type; \
    typedef __WSPR_DB_ROW_PRIMARY_KEY_REF_TYPE(member_sequence, key_sequence) primary_key_ref_type; \
    const primary_key_tie_type primary_key_tie_value() const {   \
      return primary_key_tie_type(BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_PRIMARY_KEY_ELEMENTS, member_sequence, key_sequence)); \
    } \
    const primary_key_ref_type primary_key_value() const {       \
      return BOOST_PP_IIF(BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(key_sequence)), BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_ELEM(BOOST_PP_SEQ_ELEM(0, key_sequence), member_sequence)), primary_key_tie_value()); \
    }                                                                   \
    template<typename Binder, typename KeyType>                         \
    static void bind_primary_key(Binder & binder, const KeyType & key) SSRC_DECL_THROW(NS_SSRC_WSPR_DATABASE::DatabaseException) { \
      BOOST_PP_IIF(BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(key_sequence)), binder.bind(1, key), binder.bindp(BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(key_sequence), __WSPR_DB_ROW_PRIMARY_KEY_BIND_PARAM, key))); \
    }                                                                   \
    template<typename Binder, typename KeyType>                         \
    static void bind_primary_key(Binder & binder, const KeyType & key, const unsigned int offset) SSRC_DECL_THROW(NS_SSRC_WSPR_DATABASE::DatabaseException) { \
      BOOST_PP_IIF(BOOST_PP_EQUAL(1, BOOST_PP_SEQ_SIZE(key_sequence)), binder.bind(offset + 1, key), binder BOOST_PP_REPEAT(BOOST_PP_SEQ_SIZE(key_sequence), __WSPR_DB_ROW_PRIMARY_KEY_BIND_PARAM_OFFSET, key)); \
    }                                                                   \
    template<typename Binder>                                           \
    void bind_primary_key(Binder & binder) const SSRC_DECL_THROW(NS_SSRC_WSPR_DATABASE::DatabaseException) { \
      binder.bindp(BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_PRIMARY_KEY_ELEMENTS, member_sequence, key_sequence)); \
    }                                                                   \
  };                                                                    \
  BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_KEY, name, key_sequence)        \
  BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_ELEMENT, name, member_sequence)  \
  BOOST_PP_SEQ_FOR_EACH(__WSPR_DB_ROW_IS_PRIMARY_KEY, name, key_sequence)

#define WSPR_DB_ROW_WITH_KEY(name, member_sequence, key_sequence)   \
  __WSPR_DB_ROW_WITH_KEY(name, member_sequence, key_sequence)

#define __WSPR_DB_ROW_MEMBER_INDEX_SEQ(r, data, i, arg) (i)

#define __WSPR_DB_ROW_ALL_KEYS_SEQ(member_sequence) \
  BOOST_PP_SEQ_FOR_EACH_I(__WSPR_DB_ROW_MEMBER_INDEX_SEQ, _, member_sequence)

#define WSPR_DB_ROW(name, member_sequence) \
  __WSPR_DB_ROW_WITH_KEY(name, member_sequence, __WSPR_DB_ROW_ALL_KEYS_SEQ(member_sequence))

__END_NS_SSRC_WSPR_DATABASE

#endif