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

Added into member for insert.

Browse Source 
Update and remove will get table lists with more than one table
This commit is contained in:
rbock
2014-06-05 08:32:22 +02:00
parent 067740d24e
commit 79aa358624
5 changed files with 233 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/sqlpp11/insert.h
View File

@@ -33,14 +33,14 @@
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/default_value.h>
#include <sqlpp11/vendor/noop.h>
#include <sqlpp11/vendor/single_table.h>
#include <sqlpp11/vendor/into.h>
#include <sqlpp11/vendor/insert_value_list.h>
namespace sqlpp
{
template<typename Database>
using blank_insert_t = statement_t<Database,
vendor::no_single_table_t,
vendor::no_into_t,
vendor::no_insert_value_list_t>;
auto insert()

1
include/sqlpp11/type_traits.h
View File

@@ -123,6 +123,7 @@ namespace sqlpp
SQLPP_IS_VALUE_TRAIT_GENERATOR(select_column_list);
SQLPP_IS_VALUE_TRAIT_GENERATOR(from);
SQLPP_IS_VALUE_TRAIT_GENERATOR(single_table);
SQLPP_IS_VALUE_TRAIT_GENERATOR(into);
SQLPP_IS_VALUE_TRAIT_GENERATOR(extra_tables);
SQLPP_IS_VALUE_TRAIT_GENERATOR(on);
SQLPP_IS_VALUE_TRAIT_GENERATOR(dynamic);

216
include/sqlpp11/vendor/into.h vendored Normal file
View File

@@ -0,0 +1,216 @@
/*
* Copyright (c) 2013-2014, 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_VENDOR_INTO_H
#define SQLPP_VENDOR_INTO_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/no_value.h>
#include <sqlpp11/vendor/serializer.h>
#include <sqlpp11/detail/type_set.h>
namespace sqlpp
{
namespace vendor
{
// A SINGLE TABLE DATA
template<typename Database, typename Table>
struct into_data_t
{
into_data_t(Table table):
_table(table)
{}
into_data_t(const into_data_t&) = default;
into_data_t(into_data_t&&) = default;
into_data_t& operator=(const into_data_t&) = default;
into_data_t& operator=(into_data_t&&) = default;
~into_data_t() = default;
Table _table;
};
// A SINGLE TABLE
template<typename Database, typename Table>
struct into_t
{
using _traits = make_traits<no_value_t, ::sqlpp::tag::into, tag::return_value>;
using _recursive_traits = make_recursive_traits<Table>;
static_assert(is_table_t<Table>::value, "argument has to be a table");
static_assert(required_tables_of<Table>::size::value == 0, "table depends on another table");
using _data_t = into_data_t<Database, Table>;
struct _name_t {};
// Member implementation with data and methods
template <typename Policies>
struct _impl_t
{
_data_t _data;
};
// Member template for adding the named member to a statement
template<typename Policies>
struct _member_t
{
using _data_t = into_data_t<Database, Table>;
_impl_t<Policies> into;
_impl_t<Policies>& operator()() { return into; }
const _impl_t<Policies>& operator()() const { return into; }
template<typename T>
static auto _get_member(T t) -> decltype(t.into)
{
return t.into;
}
};
// Additional methods for the statement
template<typename Policies>
struct _methods_t
{
};
template<typename Policies>
struct _result_methods_t
{
using _statement_t = typename Policies::_statement_t;
const _statement_t& _get_statement() const
{
return static_cast<const _statement_t&>(*this);
}
static constexpr size_t _get_static_no_of_parameters()
{
#warning need to fix this
return 0;
//return _parameter_list_t::size::value;
}
size_t _get_no_of_parameters() const
{
#warning need to fix this
return 0;
//return _parameter_list_t::size::value;
}
void _check_consistency() const
{
// FIXME: Read up on what is allowed/prohibited in INSERT
}
template<typename Db>
auto _run(Db& db) const -> decltype(db.insert(_get_statement()))
{
_check_consistency();
static_assert(_get_static_no_of_parameters() == 0, "cannot run insert directly with parameters, use prepare instead");
return db.insert(*this);
}
/*
template<typename Db>
auto _prepare(Db& db) const
-> prepared_insert_t<Db, insert_t>
{
_check_consistency();
return {{}, db.prepare_insert(*this)};
}
*/
};
};
// NO INTO YET
struct no_into_t
{
using _traits = make_traits<no_value_t, ::sqlpp::tag::noop>;
using _recursive_traits = make_recursive_traits<>;
// Data
using _data_t = no_data_t;
// Member implementation with data and methods
template<typename Policies>
struct _impl_t
{
_data_t _data;
};
// Member template for adding the named member to a statement
template<typename Policies>
struct _member_t
{
using _data_t = no_data_t;
_impl_t<Policies> no_into;
_impl_t<Policies>& operator()() { return no_into; }
const _impl_t<Policies>& operator()() const { return no_into; }
template<typename T>
static auto _get_member(T t) -> decltype(t.no_into)
{
return t.no_into;
}
};
template<typename Policies>
struct _methods_t
{
using _database_t = typename Policies::_database_t;
template<typename T>
using _new_statement_t = typename Policies::template _new_statement_t<no_into_t, T>;
template<typename... Args>
auto into(Args... args)
-> _new_statement_t<into_t<void, Args...>>
{
return { *static_cast<typename Policies::_statement_t*>(this), into_data_t<void, Args...>{args...} };
}
};
};
// Interpreters
template<typename Context, typename Database, typename Table>
struct serializer_t<Context, into_data_t<Database, Table>>
{
using T = into_data_t<Database, Table>;
static Context& _(const T& t, Context& context)
{
serialize(t._table, context);
return context;
}
};
}
}
#endif

27
include/sqlpp11/vendor/single_table.h vendored
View File

@@ -80,14 +80,14 @@ namespace sqlpp
{
using _data_t = single_table_data_t<Database, Table>;
_impl_t<Policies> into;
_impl_t<Policies>& operator()() { return into; }
const _impl_t<Policies>& operator()() const { return into; }
_impl_t<Policies> from;
_impl_t<Policies>& operator()() { return from; }
const _impl_t<Policies>& operator()() const { return from; }
template<typename T>
static auto _get_member(T t) -> decltype(t.into)
static auto _get_member(T t) -> decltype(t.from)
{
return t.into;
return t.from;
}
};
@@ -170,14 +170,14 @@ namespace sqlpp
{
using _data_t = no_data_t;
_impl_t<Policies> no_into;
_impl_t<Policies>& operator()() { return no_into; }
const _impl_t<Policies>& operator()() const { return no_into; }
_impl_t<Policies> no_from;
_impl_t<Policies>& operator()() { return no_from; }
const _impl_t<Policies>& operator()() const { return no_from; }
template<typename T>
static auto _get_member(T t) -> decltype(t.no_into)
static auto _get_member(T t) -> decltype(t.no_from)
{
return t.no_into;
return t.no_from;
}
};
@@ -188,13 +188,6 @@ namespace sqlpp
template<typename T>
using _new_statement_t = typename Policies::template _new_statement_t<no_single_table_t, T>;
template<typename... Args>
auto into(Args... args)
-> _new_statement_t<single_table_t<void, Args...>>
{
return { *static_cast<typename Policies::_statement_t*>(this), single_table_data_t<void, Args...>{args...} };
}
#warning: remove can operate on several tables at once, so it should not use single_table anyway
template<typename... Args>
auto from(Args... args)

8
tests/CMakeLists.txt
View File

@@ -6,10 +6,10 @@ macro (build_and_run arg)
add_test(${arg} ${arg})
endmacro ()
build_and_run(InterpretTest)
#build_and_run(InsertTest)
#build_and_run(RemoveTest)
#build_and_run(UpdateTest)
#build_and_run(InterpretTest)
build_and_run(InsertTest)
build_and_run(RemoveTest)
build_and_run(UpdateTest)
#build_and_run(SelectTest)
#build_and_run(SelectTypeTest)
#build_and_run(FunctionTest)