diff --git a/include/sqlpp11/insert.h b/include/sqlpp11/insert.h index 918b3892..f46459be 100644 --- a/include/sqlpp11/insert.h +++ b/include/sqlpp11/insert.h @@ -31,114 +31,56 @@ #include #include #include -#include #include -#include -#include +#include #include +#include +#include +#include namespace sqlpp { + namespace detail + { + template< + typename Table, + typename InsertValueList, + > + struct check_insert_t + { + //static_assert(not (vendor::is_noop::value and vendor::is_noop::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 - > - struct insert_t + template + struct insert_t: public vendor::policy_t..., public vendor::crtp_wrapper_t, Policies>... { - static_assert(vendor::is_noop::value or is_table_t
::value, "invalid 'Table' argument"); - static_assert(vendor::is_noop::value or is_insert_list_t::value, "invalid 'InsertList' argument"); - static_assert(vendor::is_noop::value or is_column_list_t::value, "invalid 'ColumnList' argument"); - static_assert(vendor::is_noop::value or is_insert_value_list_t::value, "invalid 'ValueList' argument"); + template + using _policy_update_t = insert_t...>; - using use_default_values_t = insert_t; - template - using set_insert_list_t = insert_t; - template - using set_column_value_list_t = insert_t; - - using _parameter_tuple_t = std::tuple; + using _database_t = Database; + using _parameter_tuple_t = std::tuple; using _parameter_list_t = typename make_parameter_list_t::type; - auto default_values() - -> use_default_values_t - { - static_assert(std::is_same::value, "cannot call default_values() after set() or default_values()"); - static_assert(vendor::is_noop::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 - auto set(Assignment... assignment) - -> set_insert_list_t> - { - static_assert(std::is_same::value, "cannot call set() after set() or default_values()"); - static_assert(vendor::is_noop::value, "cannot call set() after columns()"); - // FIXME: Need to check if all required columns are set - return { - _table, - vendor::insert_list_t{assignment...}, - _column_list, - _value_list, - }; - } + template + insert_t(insert_t i, Whatever whatever): + vendor::policy_t(i, whatever)... + {} - template - auto dynamic_set(Assignment... assignment) - -> set_insert_list_t> - { - static_assert(std::is_same::value, "cannot call set() after set() or default_values()"); - static_assert(vendor::is_noop::value, "cannot call set() after columns()"); - return { - _table, - vendor::insert_list_t{assignment...}, - _column_list, - _value_list, - }; - } + template + insert_t(Insert i, Whatever whatever): + vendor::policy_t(i, whatever)... + {} - template - insert_t add_set(Assignment assignment) - { - static_assert(is_dynamic_t::value, "cannot call add_set() in a non-dynamic set"); - - _insert_list.add(assignment); - - return *this; - } - - template - auto columns(Column... columns) - -> set_column_value_list_t, vendor::insert_value_list_t...>> - { - static_assert(vendor::is_noop::value, "cannot call columns() twice"); - static_assert(vendor::is_noop::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...>{{columns}...}}, - vendor::insert_value_list_t...>{}, - }; - } - - template - insert_t& add_values(Value... values) - { - static_assert(is_insert_value_list_t::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 std::size_t _run(Db& db) const { - static_assert(not (vendor::is_noop::value and vendor::is_noop::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::value, "Cannot run this insert expression"); return db.insert(*this); } @@ -162,60 +104,43 @@ namespace sqlpp auto _prepare(Db& db) const -> prepared_insert_t { - constexpr bool calledSet = not vendor::is_noop::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::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 - struct interpreter_t> + template + struct interpreter_t> { - using T = insert_t; + using T = insert_t; static Context& _(const T& t, Context& context) { - if (not vendor::is_noop::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 + using blank_insert_t = insert_t; + template - insert_t insert_into(Table table) + constexpr auto insert_into(Table table) + -> insert_t, vendor::no_insert_value_list_t> { - return {table}; + return { blank_insert_t(), vendor::single_table_t{table} }; } template - insert_t dynamic_insert_into(const Database& db, Table table) + constexpr auto dynamic_insert_into(const Database&, Table table) + -> insert_t, vendor::no_insert_value_list_t> { - return {table}; + return { blank_insert_t(), vendor::single_table_t{table} }; } } diff --git a/include/sqlpp11/remove.h b/include/sqlpp11/remove.h index d7601bc8..5d097838 100644 --- a/include/sqlpp11/remove.h +++ b/include/sqlpp11/remove.h @@ -31,7 +31,7 @@ #include #include #include -#include +#include #include #include #include @@ -42,7 +42,7 @@ namespace sqlpp { namespace detail { - template + template struct check_remove_t { static_assert(is_where_t::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(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::value, "Cannot run this expression"); + static_assert(detail::check_remove_t::value, "Cannot run this remove expression"); return db.remove(*this); } @@ -101,7 +101,7 @@ namespace sqlpp auto _prepare(Db& db) const -> prepared_remove_t { - static_assert(detail::check_remove_t::value, "Cannot run this expression"); + static_assert(detail::check_remove_t::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 - using blank_remove_t = remove_t; + using blank_remove_t = remove_t; template - constexpr remove_t, vendor::no_using_t, vendor::no_where_t> remove_from(Table table) + constexpr auto remove_from(Table table) + -> remove_t, vendor::no_using_t, vendor::no_where_t> { - return { blank_remove_t(), vendor::from_t{table} }; + return { blank_remove_t(), vendor::single_table_t{table} }; } template - constexpr remove_t, 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, vendor::no_using_t, vendor::no_where_t> { - return { blank_remove_t(), vendor::from_t{table} }; + return { blank_remove_t(), vendor::single_table_t{table} }; } } diff --git a/include/sqlpp11/vendor/insert_list.h b/include/sqlpp11/vendor/insert_list.h deleted file mode 100644 index 2d30390f..00000000 --- a/include/sqlpp11/vendor/insert_list.h +++ /dev/null @@ -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 -#include -#include -#include -#include - -namespace sqlpp -{ - namespace vendor - { - struct insert_default_values_t - { - using _is_insert_list = std::true_type; - using _is_dynamic = std::false_type; - }; - - template - struct interpreter_t - { - using T = insert_default_values_t; - - static Context& _(const T& t, Context& context) - { - context << " DEFAULT VALUES"; - return context; - } - }; - - template - struct insert_list_t - { - using _is_insert_list = std::true_type; - using _is_dynamic = typename std::conditional::value, std::false_type, std::true_type>::type; - using _parameter_tuple_t = std::tuple; - template class Target> - using copy_assignments_t = Target; // FIXME: Nice idea to copy variadic template arguments? - template class Target, template class Wrap> - using copy_wrapped_assignments_t = Target...>; - - // 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::value, "at least one duplicate argument detected in set()"); - - // check for invalid assignments - static_assert(sqlpp::detail::and_t::value, "at least one argument is not an assignment in set()"); - - // check for prohibited assignments - static_assert(not sqlpp::detail::or_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 - void add(Assignment assignment) - { - static_assert(is_assignment_t::value, "set() arguments require to be assigments"); - static_assert(not must_not_insert_t::value, "set() argument must not be used in insert"); - _dynamic_columns.emplace_back(simple_column_t{assignment._lhs}); - _dynamic_values.emplace_back(assignment._rhs); - } - - - std::tuple...> _columns; - std::tuple _values; - std::tuple _assignments; // FIXME: Need to replace _columns and _values by _assignments (connector-container requires assignments) - typename vendor::interpretable_list_t _dynamic_columns; - typename vendor::interpretable_list_t _dynamic_values; - }; - - template - struct interpreter_t> - { - using T = insert_list_t; - - 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 diff --git a/include/sqlpp11/vendor/insert_value_list.h b/include/sqlpp11/vendor/insert_value_list.h index 76fc1552..5d750be6 100644 --- a/include/sqlpp11/vendor/insert_value_list.h +++ b/include/sqlpp11/vendor/insert_value_list.h @@ -29,28 +29,102 @@ #include #include -#include #include +#include +#include +#include +#include namespace sqlpp { namespace vendor { - template - 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 + 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::value, std::false_type, std::true_type>::type; + using _parameter_tuple_t = std::tuple; + template class Target> + using copy_assignments_t = Target; // FIXME: Nice idea to copy variadic template arguments? + template class Target, template class Wrap> + using copy_wrapped_assignments_t = Target...>; - 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::value, "at least one argument is not an insert value"); + static_assert(not ::sqlpp::detail::has_duplicates::value, "at least one duplicate argument detected in set()"); - using _value_tuple_t = std::tuple; + static_assert(sqlpp::detail::and_t::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::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 + void add_set(Assignment assignment) + { + static_assert(is_assignment_t::value, "set() arguments require to be assigments"); + static_assert(not must_not_insert_t::value, "set() argument must not be used in insert"); + _dynamic_columns.emplace_back(simple_column_t{assignment._lhs}); + _dynamic_values.emplace_back(assignment._rhs); + } + + + const insert_list_t& _insert_value_list() const { return *this; } + std::tuple...> _columns; + std::tuple _values; + std::tuple _assignments; // FIXME: Need to replace _columns and _values by _assignments (connector-container requires assignments) + typename vendor::interpretable_list_t _dynamic_columns; + typename vendor::interpretable_list_t _dynamic_values; + }; + + template + struct column_list_t + { + using _is_column_list = std::true_type; + using _parameter_tuple_t = std::tuple; + + static_assert(sizeof...(Columns), "at least one column required in columns()"); + + static_assert(not ::sqlpp::detail::has_duplicates::value, "at least one duplicate argument detected in columns()"); + + static_assert(::sqlpp::detail::and_t::value, "at least one argument is not a column in columns()"); + + static_assert(not ::sqlpp::detail::or_t::value, "at least one column argument has a must_not_insert flag in its definition"); + + using _value_tuple_t = std::tuple...>; + + column_list_t(Columns... columns): + _columns(simple_column_t{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... 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...> _columns; std::vector<_value_tuple_t> _insert_values; }; - template<> - struct insert_value_list_t + 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 + struct crtp_wrapper_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 - struct interpreter_t> + template + struct crtp_wrapper_t> { - using T = insert_value_list_t; + }; + + template + struct crtp_wrapper_t> + { + }; + + template + struct crtp_wrapper_t + { + template + struct delayed_t + { + using type = Derived; + }; + + template + auto default_values() + -> vendor::update_policies_t::type, no_insert_value_list_t, insert_default_values_t> + { + return { static_cast(*this), insert_default_values_t{} }; + } + + template + auto columns(Args... args) + -> vendor::update_policies_t> + { + return { static_cast(*this), column_list_t(args...) }; + } + + template + auto set(Args... args) + -> vendor::update_policies_t> + { + return { static_cast(*this), insert_list_t(args...) }; + } + + template + auto dynamic_set(Args... args) + -> vendor::update_policies_t, Args...>> + { + static_assert(not std::is_same, void>::value, "dynamic_insert_list must not be called in a static statement"); + return { static_cast(*this), insert_list_t, Args...>(args...) }; + } + }; + + // Interpreters + template + struct interpreter_t + { + using T = insert_default_values_t; static Context& _(const T& t, Context& context) { + context << " DEFAULT VALUES"; + return context; + } + }; + + template + struct interpreter_t> + { + using T = column_list_t; + + 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 + struct interpreter_t> + { + using T = insert_list_t; + + 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 - struct interpreter_t> + struct interpreter_t { - using T = insert_value_list_t; + using T = no_insert_value_list_t; static Context& _(const T& t, Context& context) { return context; } }; + } } diff --git a/include/sqlpp11/vendor/column_list.h b/include/sqlpp11/vendor/single_table.h similarity index 52% rename from include/sqlpp11/vendor/column_list.h rename to include/sqlpp11/vendor/single_table.h index e8bbdb9a..eb77b0cf 100644 --- a/include/sqlpp11/vendor/column_list.h +++ b/include/sqlpp11/vendor/single_table.h @@ -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 -#include -#include -#include +#include +#include +#include // FIXME: REMOVE namespace sqlpp { namespace vendor { - template - struct column_list_t + // A SINGLE TABLE + template + struct single_table_t { - using _is_column_list = std::true_type; - using _parameter_tuple_t = std::tuple; + 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
::value, "argument has to be a table"); - // check for duplicate columns - static_assert(not ::sqlpp::detail::has_duplicates::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::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::value, "at least one column argument has a must_not_insert flag in its definition"); - - std::tuple...> _columns; + const single_table_t& _single_table() const { return *this; } + Table _table; }; - template - struct interpreter_t> + 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 + struct crtp_wrapper_t> { - using T = column_list_t; + }; + + template + struct crtp_wrapper_t + { + }; + + // Interpreters + template + struct interpreter_t> + { + using T = single_table_t; static Context& _(const T& t, Context& context) { - context << " ("; - interpret_tuple(t._columns, ",", context); - context << ")"; - + interpret(t._table, context); return context; } }; + } } diff --git a/tests/InterpretTest.cpp b/tests/InterpretTest.cpp index f8a7e208..d5bf6377 100644 --- a/tests/InterpretTest.cpp +++ b/tests/InterpretTest.cpp @@ -43,18 +43,19 @@ int main() test::TabFoo f; test::TabBar t; - /* interpret(insert_into(t).columns(t.gamma, t.beta), printer).flush(); - interpret(insert_into(t).columns(t.gamma, t.beta).add_values(t.gamma = true, t.beta = "cheesecake"), printer).flush(); - interpret(insert_into(t).columns(t.gamma, t.beta) - .add_values(t.gamma = true, t.beta = "cheesecake") - .add_values(t.gamma = false, t.beta = sqlpp::tvin("coffee")) - .add_values(t.gamma = false, t.beta = sqlpp::tvin(std::string())) - , printer).flush(); - interpret(insert_into(t).columns(t.gamma, t.beta) - .add_values(t.gamma = sqlpp::default_value, t.beta = sqlpp::null) - , printer).flush(); + { + auto i = insert_into(t).columns(t.gamma, t.beta); + i.add_values(t.gamma = true, t.beta = "cheesecake"); + interpret(i, printer).flush(); + i.add_values(t.gamma = false, t.beta = sqlpp::tvin("coffee")); + i.add_values(t.gamma = false, t.beta = sqlpp::tvin(std::string())); + interpret(i, printer).flush(); + i.add_values(t.gamma = sqlpp::default_value, t.beta = sqlpp::null); + interpret(i, printer).flush(); + } + /* interpret(t.alpha = sqlpp::null, printer).flush(); interpret(t.alpha = sqlpp::default_value, printer).flush(); interpret(t.alpha, printer).flush(); @@ -87,12 +88,14 @@ int main() interpret(parameter(t.alpha), printer).flush(); interpret(t.alpha == parameter(t.alpha), printer).flush(); interpret(t.alpha == parameter(t.alpha) and (t.beta + "gimmick").like(parameter(t.beta)), printer).flush(); + */ interpret(insert_into(t), printer).flush(); interpret(insert_into(f).default_values(), printer).flush(); interpret(insert_into(t).set(t.gamma = true), printer).flush(); //interpret(insert_into(t).set(t.gamma = sqlpp::tvin(false)), printer).flush(); cannot test this since gamma cannot be null and a static assert is thrown + /* interpret(update(t), printer).flush(); interpret(update(t).set(t.gamma = true), printer).flush(); interpret(update(t).set(t.gamma = true).where(t.beta.in("kaesekuchen", "cheesecake")), printer).flush();