mirror/sqlpp11
1
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2026-05-07 03:39:54 -05:00
Code Issues Packages Projects Releases Wiki Activity

Better failure return types for update and remove

Browse Source
This commit is contained in:
rbock
2016-09-01 18:22:19 +02:00
parent 36afa04bcd
commit 637e0ad4d9
5 changed files with 59 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/sqlpp11/select_pseudo_table.h
+2 -1
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* Copyright (c) 2013-2016, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@@ -28,6 +28,7 @@
#define SQLPP_SELECT_PSEUDO_TABLE_H
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/table.h>
namespace sqlpp
{
include/sqlpp11/single_table.h
+23 -18
View File
@@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2015, Roland Bock
* Copyright (c) 2013-2016, Roland Bock
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
@@ -27,12 +27,12 @@
#ifndef SQLPP_SINGLE_TABLE_H
#define SQLPP_SINGLE_TABLE_H
#include <sqlpp11/type_traits.h>
#include <sqlpp11/data_types/no_value.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/detail/type_set.h>
#include <sqlpp11/no_data.h>
#include <sqlpp11/prepared_insert.h>
#include <sqlpp11/serializer.h>
#include <sqlpp11/type_traits.h>
namespace sqlpp
{
@@ -90,8 +90,7 @@ namespace sqlpp
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
template <typename... Args>
_base_t(Args&&... args)
: from{std::forward<Args>(args)...}
_base_t(Args&&... args) : from{std::forward<Args>(args)...}
{
}
@@ -115,7 +114,16 @@ namespace sqlpp
};
};
// NO INTO YET
SQLPP_PORTABLE_STATIC_ASSERT(assert_update_table_arg_is_table_t, "argument for update() must be a table");
template <typename Table>
struct check_update_table
{
using type = static_combined_check_t<static_check_t<is_table_t<Table>::value, assert_update_table_arg_is_table_t>>;
};
template <typename Table>
using check_update_table_t = typename check_update_table<Table>::type;
// NO TABLE YET
struct no_single_table_t
{
using _traits = make_traits<no_value_t, tag::is_noop>;
@@ -154,28 +162,25 @@ namespace sqlpp
}
using _database_t = typename Policies::_database_t;
template <typename T>
using _check = logic::all_t<is_table_t<T>::value>;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_single_table_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_single_table_t, T>;
using _consistency_check = consistent_t;
template <typename Table>
auto single_table(Table table) const -> _new_statement_t<_check<Table>, single_table_t<void, Table>>
auto single_table(Table table) const -> _new_statement_t<check_update_table_t<Table>, single_table_t<void, Table>>
{
static_assert(_check<Table>::value, "argument is not a table in single_table()");
return _single_table_impl<void>(_check<Table>{}, table);
return _single_table_impl<void>(check_update_table_t<Table>{}, table);
}
private:
template <typename Database, typename Table>
auto _single_table_impl(const std::false_type&, Table table) const -> bad_statement;
template <typename Database, typename Check, typename Table>
auto _single_table_impl(Check, Table table) const -> Check;
template <typename Database, typename Table>
auto _single_table_impl(const std::true_type&, Table table) const
-> _new_statement_t<std::true_type, single_table_t<Database, Table>>
auto _single_table_impl(consistent_t, Table table) const
-> _new_statement_t<consistent_t, single_table_t<Database, Table>>
{
static_assert(required_tables_of<single_table_t<Database, Table>>::size::value == 0,
"argument depends on another table in single_table()");
include/sqlpp11/update_list.h
+5 -9
View File
@@ -250,7 +250,7 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_update_list_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_update_list_t, T>;
using _consistency_check = assert_update_assignments_t;
@@ -259,8 +259,6 @@ namespace sqlpp
-> _new_statement_t<check_update_static_set_t<Assignments...>, update_list_t<void, Assignments...>>
{
using Check = check_update_static_set_t<Assignments...>;
Check{}._();
return _set_impl<void>(Check{}, assignments...);
}
@@ -270,18 +268,16 @@ namespace sqlpp
update_list_t<_database_t, Assignments...>>
{
using Check = check_update_dynamic_set_t<_database_t, Assignments...>;
Check{}._();
return _set_impl<_database_t>(Check{}, assignments...);
}
private:
template <typename Database, typename... Assignments>
auto _set_impl(const std::false_type&, Assignments... assignments) const -> bad_statement;
template <typename Database, typename Check, typename... Assignments>
auto _set_impl(Check, Assignments... assignments) const -> Check;
template <typename Database, typename... Assignments>
auto _set_impl(const std::true_type&, Assignments... assignments) const
-> _new_statement_t<std::true_type, update_list_t<Database, Assignments...>>
auto _set_impl(consistent_t, Assignments... assignments) const
-> _new_statement_t<consistent_t, update_list_t<Database, Assignments...>>
{
return {static_cast<const derived_statement_t<Policies>&>(*this),
update_list_data_t<Database, Assignments...>{assignments...}};
include/sqlpp11/using.h
+27 -26
View File
@@ -135,6 +135,16 @@ namespace sqlpp
};
};
SQLPP_PORTABLE_STATIC_ASSERT(assert_using_args_are_tables_t, "arguments for using() must be tables");
template <typename... Tables>
struct check_using
{
using type = static_combined_check_t<
static_check_t<logic::all_t<is_table_t<Tables>::value...>::value, assert_using_args_are_tables_t>>;
};
template <typename... Tables>
using check_using_t = typename check_using<Tables...>::type;
// NO USING YET
struct no_using_t
{
@@ -187,52 +197,43 @@ namespace sqlpp
using _database_t = typename Policies::_database_t;
// workaround for msvc bug https://connect.microsoft.com/VisualStudio/Feedback/Details/2173269
// template <typename... T>
// using _check = logic::all_t<is_table_t<T>::value...>;
template <typename... T>
struct _check : logic::all_t<is_table_t<T>::value...>
{
};
template <typename Check, typename T>
using _new_statement_t = new_statement_t<Check::value, Policies, no_using_t, T>;
using _new_statement_t = new_statement_t<Check, Policies, no_using_t, T>;
using _consistency_check = consistent_t;
template <typename... Args>
auto using_(Args... args) const -> _new_statement_t<_check<Args...>, using_t<void, Args...>>
template <typename... Tables>
auto using_(Tables... tables) const -> _new_statement_t<check_using_t<Tables...>, using_t<void, Tables...>>
{
static_assert(not detail::has_duplicates<Args...>::value,
static_assert(not detail::has_duplicates<Tables...>::value,
"at least one duplicate argument detected in using()");
static_assert(sizeof...(Args), "at least one table required in using()");
static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
static_assert(sizeof...(Tables), "at least one table required in using()");
return {_using_impl<void>(_check<Args...>{}, args...)};
return {_using_impl<void>(check_using_t<Tables...>{}, tables...)};
}
template <typename... Args>
auto dynamic_using(Args... args) const -> _new_statement_t<_check<Args...>, using_t<_database_t, Args...>>
template <typename... Tables>
auto dynamic_using(Tables... tables) const
-> _new_statement_t<check_using_t<Tables...>, using_t<_database_t, Tables...>>
{
static_assert(not std::is_same<_database_t, void>::value,
"dynamic_using must not be called in a static statement");
static_assert(_check<Args...>::value, "at least one argument is not an table in using()");
return {_using_impl<_database_t>(_check<Args...>{}, args...)};
return {_using_impl<_database_t>(check_using_t<Tables...>{}, tables...)};
}
private:
template <typename Database, typename... Args>
auto _using_impl(const std::false_type&, Args... args) const -> bad_statement;
template <typename Database, typename Check, typename... Tables>
auto _using_impl(Check, Tables... tables) const -> Check;
template <typename Database, typename... Args>
auto _using_impl(const std::true_type&, Args... args) const
-> _new_statement_t<std::true_type, using_t<_database_t, Args...>>
template <typename Database, typename... Tables>
auto _using_impl(consistent_t, Tables... tables) const
-> _new_statement_t<consistent_t, using_t<_database_t, Tables...>>
{
static_assert(not detail::has_duplicates<Args...>::value,
static_assert(not detail::has_duplicates<Tables...>::value,
"at least one duplicate argument detected in using()");
return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Args...>{args...}};
return {static_cast<const derived_statement_t<Policies>&>(*this), using_data_t<Database, Tables...>{tables...}};
}
};
};