mirror/sqlpp11
1
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2026-01-05 20:50:34 -06:00
Code Issues Packages Projects Releases Wiki Activity

Refactored insert to use policies

Browse Source 
Much cleaner now.
This commit is contained in:
rbock
2014-02-08 21:06:23 +01:00
parent 5b67061fca
commit 68750aac80
6 changed files with 323 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
include/sqlpp11/insert.h
View File

@@ -31,114 +31,56 @@
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/default_value.h>
#include <sqlpp11/vendor/column_list.h>
#include <sqlpp11/vendor/noop.h>
#include <sqlpp11/vendor/insert_list.h>
#include <sqlpp11/vendor/assignment.h>
#include <sqlpp11/vendor/single_table.h>
#include <sqlpp11/vendor/insert_value_list.h>
#include <sqlpp11/vendor/crtp_wrapper.h>
#include <sqlpp11/vendor/policy.h>
#include <sqlpp11/vendor/policy_update.h>
namespace sqlpp
{
namespace detail
{
template<
typename Table,
typename InsertValueList,
>
struct check_insert_t
{
//static_assert(not (vendor::is_noop<InsertList>::value and vendor::is_noop<ColumnList>::value) , "calling set() or default_values()");
static constexpr bool value = true;
};
}
template<
typename Database = void,
typename Table = vendor::noop,
typename InsertList = vendor::noop,
typename ColumnList = vendor::noop,
typename ValueList = vendor::insert_value_list_t<vendor::noop>
>
struct insert_t
template<typename Database, typename... Policies>
struct insert_t: public vendor::policy_t<Policies>..., public vendor::crtp_wrapper_t<insert_t<Database, Policies...>, Policies>...
{
static_assert(vendor::is_noop<Table>::value or is_table_t<Table>::value, "invalid 'Table' argument");
static_assert(vendor::is_noop<InsertList>::value or is_insert_list_t<InsertList>::value, "invalid 'InsertList' argument");
static_assert(vendor::is_noop<ColumnList>::value or is_column_list_t<ColumnList>::value, "invalid 'ColumnList' argument");
static_assert(vendor::is_noop<ValueList>::value or is_insert_value_list_t<ValueList>::value, "invalid 'ValueList' argument");
template<typename Needle, typename Replacement>
using _policy_update_t = insert_t<Database, vendor::policy_update_t<Policies, Needle, Replacement>...>;
using use_default_values_t = insert_t<Database, Table, vendor::insert_default_values_t>;
template<typename AssignmentT>
using set_insert_list_t = insert_t<Database, Table, AssignmentT>;
template<typename ColumnT, typename ValueT>
using set_column_value_list_t = insert_t<Database, Table, InsertList, ColumnT, ValueT>;
using _parameter_tuple_t = std::tuple<Table, InsertList>;
using _database_t = Database;
using _parameter_tuple_t = std::tuple<Policies...>;
using _parameter_list_t = typename make_parameter_list_t<insert_t>::type;
auto default_values()
-> use_default_values_t
{
static_assert(std::is_same<InsertList, vendor::noop>::value, "cannot call default_values() after set() or default_values()");
static_assert(vendor::is_noop<ColumnList>::value, "cannot call default_values() after columns()");
static_assert(Table::_required_insert_columns::size::value == 0, "cannot use default_values, because some columns are configured to require values");
return {
_table,
{},
_column_list,
_value_list,
};
}
insert_t()
{}
template<typename... Assignment>
auto set(Assignment... assignment)
-> set_insert_list_t<vendor::insert_list_t<void, Assignment...>>
{
static_assert(std::is_same<InsertList, vendor::noop>::value, "cannot call set() after set() or default_values()");
static_assert(vendor::is_noop<ColumnList>::value, "cannot call set() after columns()");
// FIXME: Need to check if all required columns are set
return {
_table,
vendor::insert_list_t<void, Assignment...>{assignment...},
_column_list,
_value_list,
};
}
template<typename Whatever>
insert_t(insert_t i, Whatever whatever):
vendor::policy_t<Policies>(i, whatever)...
{}
template<typename... Assignment>
auto dynamic_set(Assignment... assignment)
-> set_insert_list_t<vendor::insert_list_t<Database, Assignment...>>
{
static_assert(std::is_same<InsertList, vendor::noop>::value, "cannot call set() after set() or default_values()");
static_assert(vendor::is_noop<ColumnList>::value, "cannot call set() after columns()");
return {
_table,
vendor::insert_list_t<Database, Assignment...>{assignment...},
_column_list,
_value_list,
};
}
template<typename Insert, typename Whatever>
insert_t(Insert i, Whatever whatever):
vendor::policy_t<Policies>(i, whatever)...
{}
template<typename Assignment>
insert_t add_set(Assignment assignment)
{
static_assert(is_dynamic_t<InsertList>::value, "cannot call add_set() in a non-dynamic set");
_insert_list.add(assignment);
return *this;
}
template<typename... Column>
auto columns(Column... columns)
-> set_column_value_list_t<vendor::column_list_t<Column...>, vendor::insert_value_list_t<vendor::insert_value_t<Column>...>>
{
static_assert(vendor::is_noop<ColumnList>::value, "cannot call columns() twice");
static_assert(vendor::is_noop<InsertList>::value, "cannot call columns() after set() or dynamic_set()");
// FIXME: Need to check if all required columns are set
return {
_table,
_insert_list,
{std::tuple<vendor::simple_column_t<Column>...>{{columns}...}},
vendor::insert_value_list_t<vendor::insert_value_t<Column>...>{},
};
}
template<typename... Value>
insert_t& add_values(Value... values)
{
static_assert(is_insert_value_list_t<ValueList>::value, "cannot call add_values() before columns()");
_value_list.add(typename ValueList::_value_tuple_t{values...});
return *this;
};
insert_t(const insert_t&) = default;
insert_t(insert_t&&) = default;
insert_t& operator=(const insert_t&) = default;
insert_t& operator=(insert_t&&) = default;
~insert_t() = default;
static constexpr size_t _get_static_no_of_parameters()
{
@@ -153,8 +95,8 @@ namespace sqlpp
template<typename Db>
std::size_t _run(Db& db) const
{
static_assert(not (vendor::is_noop<InsertList>::value and vendor::is_noop<ColumnList>::value) , "calling set() or default_values()");
static_assert(_get_static_no_of_parameters() == 0, "cannot run insert directly with parameters, use prepare instead");
static_assert(detail::check_insert_t<Policies...>::value, "Cannot run this insert expression");
return db.insert(*this);
}
@@ -162,60 +104,43 @@ namespace sqlpp
auto _prepare(Db& db) const
-> prepared_insert_t<Db, insert_t>
{
constexpr bool calledSet = not vendor::is_noop<InsertList>::value;
constexpr bool requireSet = Table::_required_insert_columns::size::value > 0;
static_assert(calledSet or not requireSet, "calling set() required for given table");
static_assert(detail::check_insert_t<Policies...>::value, "Cannot prepare this insert expression");
return {{}, db.prepare_insert(*this)};
}
Table _table;
InsertList _insert_list;
ColumnList _column_list;
ValueList _value_list;
};
namespace vendor
{
template<typename Context, typename Database, typename Table, typename InsertList, typename ColumnList, typename ValueList>
struct interpreter_t<Context, insert_t<Database, Table, InsertList, ColumnList, ValueList>>
template<typename Context, typename Database, typename... Policies>
struct interpreter_t<Context, insert_t<Database, Policies...>>
{
using T = insert_t<Database, Table, InsertList, ColumnList, ValueList>;
using T = insert_t<Database, Policies...>;
static Context& _(const T& t, Context& context)
{
if (not vendor::is_noop<decltype(t._insert_list)>::value)
{
context << "INSERT INTO ";
interpret(t._table, context);
interpret(t._insert_list, context);
}
else if (not t._value_list.empty())
{
context << "INSERT INTO ";
interpret(t._table, context);
interpret(t._column_list, context);
interpret(t._value_list, context);
}
else
{
context << "# empty insert";
}
context << "INSERT INTO ";
interpret(t._single_table(), context);
interpret(t._insert_value_list(), context);
return context;
}
};
}
template<typename Database>
using blank_insert_t = insert_t<Database, vendor::no_single_table_t, vendor::no_insert_value_list_t>;
template<typename Table>
insert_t<void, Table> insert_into(Table table)
constexpr auto insert_into(Table table)
-> insert_t<void, vendor::single_table_t<void, Table>, vendor::no_insert_value_list_t>
{
return {table};
return { blank_insert_t<void>(), vendor::single_table_t<void, Table>{table} };
}
template<typename Database, typename Table>
insert_t<Database, Table> dynamic_insert_into(const Database& db, Table table)
constexpr auto dynamic_insert_into(const Database&, Table table)
-> insert_t<Database, vendor::single_table_t<void, Table>, vendor::no_insert_value_list_t>
{
return {table};
return { blank_insert_t<Database>(), vendor::single_table_t<Database, Table>{table} };
}
}

32
include/sqlpp11/remove.h
View File

@@ -31,7 +31,7 @@
#include <sqlpp11/parameter_list.h>
#include <sqlpp11/prepared_remove.h>
#include <sqlpp11/vendor/noop.h>
#include <sqlpp11/vendor/from.h>
#include <sqlpp11/vendor/single_table.h>
#include <sqlpp11/vendor/using.h>
#include <sqlpp11/vendor/where.h>
#include <sqlpp11/vendor/crtp_wrapper.h>
@@ -42,7 +42,7 @@ namespace sqlpp
{
namespace detail
{
template<typename From, typename Using, typename Where>
template<typename Table, typename Using, typename Where>
struct check_remove_t
{
static_assert(is_where_t<Where>::value, "cannot run remove without having a where condition, use .where(true) to remove all rows");
@@ -73,10 +73,10 @@ namespace sqlpp
vendor::policy_t<Policies>(r, whatever)...
{}
remove_t(const remove_t& r) = default;
remove_t(remove_t&& r) = default;
remove_t& operator=(const remove_t& r) = default;
remove_t& operator=(remove_t&& r) = default;
remove_t(const remove_t&) = default;
remove_t(remove_t&&) = default;
remove_t& operator=(const remove_t&) = default;
remove_t& operator=(remove_t&&) = default;
~remove_t() = default;
static constexpr size_t _get_static_no_of_parameters()
@@ -93,7 +93,7 @@ namespace sqlpp
std::size_t _run(Db& db) const
{
static_assert(_get_static_no_of_parameters() == 0, "cannot run remove directly with parameters, use prepare instead");
static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this expression");
static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this remove expression");
return db.remove(*this);
}
@@ -101,7 +101,7 @@ namespace sqlpp
auto _prepare(Db& db) const
-> prepared_remove_t<Database, remove_t>
{
static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this expression");
static_assert(detail::check_remove_t<Policies...>::value, "Cannot run this remove expression");
return {{}, db.prepare_remove(*this)};
}
};
@@ -115,8 +115,8 @@ namespace sqlpp
static Context& _(const T& t, Context& context)
{
context << "DELETE";
interpret(t._from(), context);
context << "DELETE FROM";
interpret(t._single_table(), context);
interpret(t._using(), context);
interpret(t._where(), context);
return context;
@@ -125,18 +125,20 @@ namespace sqlpp
}
template<typename Database>
using blank_remove_t = remove_t<Database, vendor::no_from_t, vendor::no_using_t, vendor::no_where_t>;
using blank_remove_t = remove_t<Database, vendor::no_single_table_t, vendor::no_using_t, vendor::no_where_t>;
template<typename Table>
constexpr remove_t<void, vendor::from_t<void, Table>, vendor::no_using_t, vendor::no_where_t> remove_from(Table table)
constexpr auto remove_from(Table table)
-> remove_t<void, vendor::single_table_t<void, Table>, vendor::no_using_t, vendor::no_where_t>
{
return { blank_remove_t<void>(), vendor::from_t<void, Table>{table} };
return { blank_remove_t<void>(), vendor::single_table_t<void, Table>{table} };
}
template<typename Database, typename Table>
constexpr remove_t<Database, vendor::from_t<void, Table>, vendor::no_using_t, vendor::no_where_t> dynamic_remove_from(const Database&, Table table)
constexpr auto dynamic_remove_from(const Database&, Table table)
-> remove_t<Database, vendor::single_table_t<void, Table>, vendor::no_using_t, vendor::no_where_t>
{
return { blank_remove_t<Database>(), vendor::from_t<Database, Table>{table} };
return { blank_remove_t<Database>(), vendor::single_table_t<Database, Table>{table} };
}
}

141
include/sqlpp11/vendor/insert_list.h vendored
View File

@@ -1,141 +0,0 @@
/*
* Copyright (c) 2013, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SQLPP_INSERT_LIST_H
#define SQLPP_INSERT_LIST_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/vendor/interpret_tuple.h>
#include <sqlpp11/vendor/interpretable_list.h>
#include <sqlpp11/vendor/simple_column.h>
#include <sqlpp11/detail/logic.h>
namespace sqlpp
{
namespace vendor
{
struct insert_default_values_t
{
using _is_insert_list = std::true_type;
using _is_dynamic = std::false_type;
};
template<typename Context>
struct interpreter_t<Context, insert_default_values_t>
{
using T = insert_default_values_t;
static Context& _(const T& t, Context& context)
{
context << " DEFAULT VALUES";
return context;
}
};
template<typename Database, typename... Assignments>
struct insert_list_t
{
using _is_insert_list = std::true_type;
using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
using _parameter_tuple_t = std::tuple<Assignments...>;
template<template<typename...> class Target>
using copy_assignments_t = Target<Assignments...>; // FIXME: Nice idea to copy variadic template arguments?
template<template<typename...> class Target, template<typename> class Wrap>
using copy_wrapped_assignments_t = Target<Wrap<Assignments>...>;
// check for at least one order expression
static_assert(_is_dynamic::value or sizeof...(Assignments), "at least one select expression required in set()");
// check for duplicate assignments
static_assert(not ::sqlpp::detail::has_duplicates<Assignments...>::value, "at least one duplicate argument detected in set()");
// check for invalid assignments
static_assert(sqlpp::detail::and_t<is_assignment_t, Assignments...>::value, "at least one argument is not an assignment in set()");
// check for prohibited assignments
static_assert(not sqlpp::detail::or_t<must_not_insert_t, typename Assignments::_column_t...>::value, "at least one assignment is prohibited by its column definition in set()");
insert_list_t(Assignments... assignment):
_assignments(assignment...),
_columns({assignment._lhs}...),
_values(assignment._rhs...)
{}
insert_list_t(const insert_list_t&) = default;
insert_list_t(insert_list_t&&) = default;
insert_list_t& operator=(const insert_list_t&) = default;
insert_list_t& operator=(insert_list_t&&) = default;
~insert_list_t() = default;
template<typename Assignment>
void add(Assignment assignment)
{
static_assert(is_assignment_t<Assignment>::value, "set() arguments require to be assigments");
static_assert(not must_not_insert_t<Assignment>::value, "set() argument must not be used in insert");
_dynamic_columns.emplace_back(simple_column_t<typename Assignment::_column_t>{assignment._lhs});
_dynamic_values.emplace_back(assignment._rhs);
}
std::tuple<simple_column_t<typename Assignments::_column_t>...> _columns;
std::tuple<typename Assignments::value_type...> _values;
std::tuple<Assignments...> _assignments; // FIXME: Need to replace _columns and _values by _assignments (connector-container requires assignments)
typename vendor::interpretable_list_t<Database> _dynamic_columns;
typename vendor::interpretable_list_t<Database> _dynamic_values;
};
template<typename Context, typename Database, typename... Assignments>
struct interpreter_t<Context, insert_list_t<Database, Assignments...>>
{
using T = insert_list_t<Database, Assignments...>;
static Context& _(const T& t, Context& context)
{
if (sizeof...(Assignments) + t._dynamic_columns.size() == 0)
{
interpret(insert_default_values_t(), context);
}
else
{
context << " (";
interpret_tuple(t._columns, ",", context);
if (sizeof...(Assignments) and not t._dynamic_columns.empty())
context << ',';
interpret_list(t._dynamic_columns, ',', context);
context << ") VALUES(";
interpret_tuple(t._values, ",", context);
if (sizeof...(Assignments) and not t._dynamic_values.empty())
context << ',';
interpret_list(t._dynamic_values, ',', context);
context << ")";
}
return context;
}
};
}
}
#endif

225
include/sqlpp11/vendor/insert_value_list.h vendored
View File

@@ -29,28 +29,102 @@
#include <sqlpp11/type_traits.h>
#include <sqlpp11/detail/logic.h>
#include <sqlpp11/vendor/insert_value.h>
#include <sqlpp11/vendor/interpret_tuple.h>
#include <sqlpp11/vendor/insert_value.h>
#include <sqlpp11/vendor/simple_column.h>
#include <sqlpp11/vendor/policy_update.h>
#include <sqlpp11/vendor/crtp_wrapper.h>
namespace sqlpp
{
namespace vendor
{
template<typename... InsertValues>
struct insert_value_list_t
// COLUMN AND VALUE LIST
struct insert_default_values_t
{
using _is_insert_list = std::true_type;
using _is_dynamic = std::false_type;
const insert_default_values_t& _insert_value_list() const { return *this; }
};
template<typename Database, typename... Assignments>
struct insert_list_t
{
using _is_insert_value_list = std::true_type;
using _is_insert_list = std::true_type;
using _is_dynamic = typename std::conditional<std::is_same<Database, void>::value, std::false_type, std::true_type>::type;
using _parameter_tuple_t = std::tuple<Assignments...>;
template<template<typename...> class Target>
using copy_assignments_t = Target<Assignments...>; // FIXME: Nice idea to copy variadic template arguments?
template<template<typename...> class Target, template<typename> class Wrap>
using copy_wrapped_assignments_t = Target<Wrap<Assignments>...>;
static_assert(sizeof...(InsertValues), "at least one insert value required");
static_assert(_is_dynamic::value or sizeof...(Assignments), "at least one select expression required in set()");
// check for invalid arguments
static_assert(::sqlpp::detail::and_t<is_insert_value_t, InsertValues...>::value, "at least one argument is not an insert value");
static_assert(not ::sqlpp::detail::has_duplicates<Assignments...>::value, "at least one duplicate argument detected in set()");
using _value_tuple_t = std::tuple<InsertValues...>;
static_assert(sqlpp::detail::and_t<is_assignment_t, Assignments...>::value, "at least one argument is not an assignment in set()");
void add(_value_tuple_t value_tuple)
static_assert(not sqlpp::detail::or_t<must_not_insert_t, typename Assignments::_column_t...>::value, "at least one assignment is prohibited by its column definition in set()");
insert_list_t(Assignments... assignment):
_assignments(assignment...),
_columns({assignment._lhs}...),
_values(assignment._rhs...)
{}
insert_list_t(const insert_list_t&) = default;
insert_list_t(insert_list_t&&) = default;
insert_list_t& operator=(const insert_list_t&) = default;
insert_list_t& operator=(insert_list_t&&) = default;
~insert_list_t() = default;
template<typename Assignment>
void add_set(Assignment assignment)
{
static_assert(is_assignment_t<Assignment>::value, "set() arguments require to be assigments");
static_assert(not must_not_insert_t<Assignment>::value, "set() argument must not be used in insert");
_dynamic_columns.emplace_back(simple_column_t<typename Assignment::_column_t>{assignment._lhs});
_dynamic_values.emplace_back(assignment._rhs);
}
const insert_list_t& _insert_value_list() const { return *this; }
std::tuple<simple_column_t<typename Assignments::_column_t>...> _columns;
std::tuple<typename Assignments::value_type...> _values;
std::tuple<Assignments...> _assignments; // FIXME: Need to replace _columns and _values by _assignments (connector-container requires assignments)
typename vendor::interpretable_list_t<Database> _dynamic_columns;
typename vendor::interpretable_list_t<Database> _dynamic_values;
};
template<typename... Columns>
struct column_list_t
{
using _is_column_list = std::true_type;
using _parameter_tuple_t = std::tuple<Columns...>;
static_assert(sizeof...(Columns), "at least one column required in columns()");
static_assert(not ::sqlpp::detail::has_duplicates<Columns...>::value, "at least one duplicate argument detected in columns()");
static_assert(::sqlpp::detail::and_t<is_column_t, Columns...>::value, "at least one argument is not a column in columns()");
static_assert(not ::sqlpp::detail::or_t<must_not_insert_t, Columns...>::value, "at least one column argument has a must_not_insert flag in its definition");
using _value_tuple_t = std::tuple<vendor::insert_value_t<Columns>...>;
column_list_t(Columns... columns):
_columns(simple_column_t<Columns>{columns}...)
{}
column_list_t(const column_list_t&) = default;
column_list_t(column_list_t&&) = default;
column_list_t& operator=(const column_list_t&) = default;
column_list_t& operator=(column_list_t&&) = default;
~column_list_t() = default;
void add_values(vendor::insert_value_t<Columns>... values)
{
_insert_values.emplace_back(value_tuple);
_insert_values.emplace_back(values...);
}
bool empty() const
@@ -58,33 +132,95 @@ namespace sqlpp
return _insert_values.empty();
}
const column_list_t& _insert_value_list() const { return *this; }
std::tuple<simple_column_t<Columns>...> _columns;
std::vector<_value_tuple_t> _insert_values;
};
template<>
struct insert_value_list_t<noop>
struct no_insert_value_list_t
{
using _is_insert_value_list = std::true_type;
const no_insert_value_list_t& _insert_value_list() const { return *this; }
};
// CRTP Wrappers
template<typename Derived>
struct crtp_wrapper_t<Derived, insert_default_values_t>
{
using _is_insert_value_list = std::true_type;
using _value_tuple_t = std::tuple<>;
void add(_value_tuple_t value_tuple)
{
}
static constexpr bool empty()
{
return true;
}
};
template<typename Context, typename... InsertValues>
struct interpreter_t<Context, insert_value_list_t<InsertValues...>>
template<typename Derived, typename Database, typename... Args>
struct crtp_wrapper_t<Derived, column_list_t<Database, Args...>>
{
using T = insert_value_list_t<InsertValues...>;
};
template<typename Derived, typename Database, typename... Args>
struct crtp_wrapper_t<Derived, insert_list_t<Database, Args...>>
{
};
template<typename Derived>
struct crtp_wrapper_t<Derived, no_insert_value_list_t>
{
template<typename... Args>
struct delayed_t
{
using type = Derived;
};
template<typename Arg = void>
auto default_values()
-> vendor::update_policies_t<typename delayed_t<Arg>::type, no_insert_value_list_t, insert_default_values_t>
{
return { static_cast<Derived&>(*this), insert_default_values_t{} };
}
template<typename... Args>
auto columns(Args... args)
-> vendor::update_policies_t<Derived, no_insert_value_list_t, column_list_t<Args...>>
{
return { static_cast<Derived&>(*this), column_list_t<Args...>(args...) };
}
template<typename... Args>
auto set(Args... args)
-> vendor::update_policies_t<Derived, no_insert_value_list_t, insert_list_t<void, Args...>>
{
return { static_cast<Derived&>(*this), insert_list_t<void, Args...>(args...) };
}
template<typename... Args>
auto dynamic_set(Args... args)
-> vendor::update_policies_t<Derived, no_insert_value_list_t, insert_list_t<get_database_t<Derived>, Args...>>
{
static_assert(not std::is_same<get_database_t<Derived>, void>::value, "dynamic_insert_list must not be called in a static statement");
return { static_cast<Derived&>(*this), insert_list_t<get_database_t<Derived>, Args...>(args...) };
}
};
// Interpreters
template<typename Context>
struct interpreter_t<Context, insert_default_values_t>
{
using T = insert_default_values_t;
static Context& _(const T& t, Context& context)
{
context << " DEFAULT VALUES";
return context;
}
};
template<typename Context, typename... Columns>
struct interpreter_t<Context, column_list_t<Columns...>>
{
using T = column_list_t<Columns...>;
static Context& _(const T& t, Context& context)
{
context << " (";
interpret_tuple(t._columns, ",", context);
context << ")";
context << " VALUES ";
bool first = true;
for (const auto& row : t._insert_values)
@@ -97,20 +233,51 @@ namespace sqlpp
interpret_tuple(row, ",", context);
context << ')';
}
return context;
}
};
template<typename Context, typename Database, typename... Assignments>
struct interpreter_t<Context, insert_list_t<Database, Assignments...>>
{
using T = insert_list_t<Database, Assignments...>;
static Context& _(const T& t, Context& context)
{
if (sizeof...(Assignments) + t._dynamic_columns.size() == 0)
{
interpret(insert_default_values_t(), context);
}
else
{
context << " (";
interpret_tuple(t._columns, ",", context);
if (sizeof...(Assignments) and not t._dynamic_columns.empty())
context << ',';
interpret_list(t._dynamic_columns, ',', context);
context << ") VALUES(";
interpret_tuple(t._values, ",", context);
if (sizeof...(Assignments) and not t._dynamic_values.empty())
context << ',';
interpret_list(t._dynamic_values, ',', context);
context << ")";
}
return context;
}
};
template<typename Context>
struct interpreter_t<Context, insert_value_list_t<noop>>
struct interpreter_t<Context, no_insert_value_list_t>
{
using T = insert_value_list_t<noop>;
using T = no_insert_value_list_t;
static Context& _(const T& t, Context& context)
{
return context;
}
};
}
}

69
include/sqlpp11/vendor/column_list.h → include/sqlpp11/vendor/single_table.h vendored
View File

@@ -24,53 +24,70 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SQLPP_COLUMN_LIST_H
#define SQLPP_COLUMN_LIST_H
#ifndef SQLPP_VENDOR_SINGLE_TABLE_H
#define SQLPP_VENDOR_SINGLE_TABLE_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/detail/logic.h>
#include <sqlpp11/vendor/interpret_tuple.h>
#include <sqlpp11/vendor/simple_column.h>
#include <sqlpp11/vendor/policy_update.h>
#include <sqlpp11/vendor/crtp_wrapper.h>
#include <iostream> // FIXME: REMOVE
namespace sqlpp
{
namespace vendor
{
template<typename... Columns>
struct column_list_t
// A SINGLE TABLE
template<typename Database, typename Table>
struct single_table_t
{
using _is_column_list = std::true_type;
using _parameter_tuple_t = std::tuple<Columns...>;
using _is_single_table = std::true_type;
// check for at least one order column
static_assert(sizeof...(Columns), "at least one column required in columns()");
static_assert(is_table_t<Table>::value, "argument has to be a table");
// check for duplicate columns
static_assert(not ::sqlpp::detail::has_duplicates<Columns...>::value, "at least one duplicate argument detected in columns()");
single_table_t(Table table):
_table(table)
{}
// check for invalid columns
static_assert(::sqlpp::detail::and_t<is_column_t, Columns...>::value, "at least one argument is not a column in columns()");
single_table_t(const single_table_t&) = default;
single_table_t(single_table_t&&) = default;
single_table_t& operator=(const single_table_t&) = default;
single_table_t& operator=(single_table_t&&) = default;
~single_table_t() = default;
// check for prohibited columns
static_assert(not ::sqlpp::detail::or_t<must_not_insert_t, Columns...>::value, "at least one column argument has a must_not_insert flag in its definition");
std::tuple<simple_column_t<Columns>...> _columns;
const single_table_t& _single_table() const { return *this; }
Table _table;
};
template<typename Context, typename... Columns>
struct interpreter_t<Context, column_list_t<Columns...>>
struct no_single_table_t
{
using _is_single_table = std::true_type;
const no_single_table_t& _single_table() const { return *this; }
};
// CRTP Wrappers
template<typename Derived, typename Database, typename Table>
struct crtp_wrapper_t<Derived, single_table_t<Database, Table>>
{
using T = column_list_t<Columns...>;
};
template<typename Derived>
struct crtp_wrapper_t<Derived, no_single_table_t>
{
};
// Interpreters
template<typename Context, typename Database, typename Table>
struct interpreter_t<Context, single_table_t<Database, Table>>
{
using T = single_table_t<Database, Table>;
static Context& _(const T& t, Context& context)
{
context << " (";
interpret_tuple(t._columns, ",", context);
context << ")";
interpret(t._table, context);
return context;
}
};
}
}