Skip to content

Commit 15bee9c

Browse files
trueqbittrueqbit
committed
Merge remote-tracking branch 'upstream/dev' into issues/#1149/2
2 parents 72b09de + 246f974 commit 15bee9c

File tree

9 files changed

+92
-72
lines changed

9 files changed

+92
-72
lines changed

‎dev/ast/upsert_clause.h‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,9 @@
11
#pragma once
22

3-
#include <tuple> // std::tuple, std::make_tuple
4-
#include <type_traits> // std::false_type, std::true_type
3+
#if SQLITE_VERSION_NUMBER >= 3024000
4+
#include <tuple> // std::tuple
55
#include <utility> // std::forward, std::move
6+
#endif
67

78
#include "../functional/cxx_type_traits_polyfill.h"
89

@@ -24,7 +25,7 @@ namespace sqlite_orm {
2425

2526
template<class... ActionsArgs>
2627
upsert_clause<args_tuple, std::tuple<ActionsArgs...>> do_update(ActionsArgs... actions) {
27-
return {std::move(this->args), {std::make_tuple(std::forward<ActionsArgs>(actions)...)}};
28+
return {std::move(this->args), {std::forward<ActionsArgs>(actions)...}};
2829
}
2930
};
3031

@@ -40,8 +41,13 @@ namespace sqlite_orm {
4041

4142
template<class T>
4243
using is_upsert_clause = polyfill::is_specialization_of<T, upsert_clause>;
44+
#else
45+
template<class T>
46+
struct is_upsert_clause : polyfill::bool_constant<false> {};
47+
#endif
4348
}
4449

50+
#if SQLITE_VERSION_NUMBER >= 3024000
4551
/**
4652
* ON CONFLICT upsert clause builder function.
4753
* @example

‎dev/ast_iterator.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -105,9 +105,9 @@ namespace sqlite_orm {
105105
}
106106
};
107107

108-
template<class... TargetArgs, class... ActionsArgs>
109-
struct ast_iterator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
110-
using node_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
108+
template<class T>
109+
struct ast_iterator<T, match_if<is_upsert_clause, T>> {
110+
using node_type = T;
111111

112112
template<class L>
113113
void operator()(const node_type& expression, L& lambda) const {

‎dev/node_tuple.h‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -54,9 +54,8 @@ namespace sqlite_orm {
5454
using type = tuple_cat_t<args_tuple, expression_tuple>;
5555
};
5656

57-
template<class... TargetArgs, class... ActionsArgs>
58-
struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void>
59-
: node_tuple<std::tuple<ActionsArgs...>> {};
57+
template<class T>
58+
struct node_tuple<T, match_if<is_upsert_clause, T>> : node_tuple<typename T::actions_tuple> {};
6059

6160
template<class... Args>
6261
struct node_tuple<set_t<Args...>, void> {

‎dev/statement_serializer.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -224,9 +224,9 @@ namespace sqlite_orm {
224224
}
225225
};
226226

227-
template<class... TargetArgs, class... ActionsArgs>
228-
struct statement_serializer<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
229-
using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
227+
template<class T>
228+
struct statement_serializer<T, match_if<is_upsert_clause, T>> {
229+
using statement_type = T;
230230

231231
template<class Ctx>
232232
std::string operator()(const statement_type& statement, const Ctx& context) const {

‎dev/table.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,8 @@ namespace sqlite_orm {
110110
constexpr size_t opIndex = first_index_sequence_value(generated_op_index_sequence{});
111111
result = &get<opIndex>(column.constraints).storage;
112112
});
113+
#else
114+
(void)name;
113115
#endif
114116
return result;
115117
}

‎include/sqlite_orm/sqlite_orm.h‎

Lines changed: 67 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -9767,6 +9767,8 @@ namespace sqlite_orm {
97679767
constexpr size_t opIndex = first_index_sequence_value(generated_op_index_sequence{});
97689768
result = &get<opIndex>(column.constraints).storage;
97699769
});
9770+
#else
9771+
(void)name;
97709772
#endif
97719773
return result;
97729774
}
@@ -11327,9 +11329,10 @@ namespace sqlite_orm {
1132711329

1132811330
// #include "ast/upsert_clause.h"
1132911331

11330-
#include <tuple> // std::tuple, std::make_tuple
11331-
#include <type_traits> // std::false_type, std::true_type
11332+
#if SQLITE_VERSION_NUMBER >= 3024000
11333+
#include <tuple> // std::tuple
1133211334
#include <utility> // std::forward, std::move
11335+
#endif
1133311336

1133411337
// #include "../functional/cxx_type_traits_polyfill.h"
1133511338

@@ -11351,7 +11354,7 @@ namespace sqlite_orm {
1135111354

1135211355
template<class... ActionsArgs>
1135311356
upsert_clause<args_tuple, std::tuple<ActionsArgs...>> do_update(ActionsArgs... actions) {
11354-
return {std::move(this->args), {std::make_tuple(std::forward<ActionsArgs>(actions)...)}};
11357+
return {std::move(this->args), {std::forward<ActionsArgs>(actions)...}};
1135511358
}
1135611359
};
1135711360

@@ -11367,8 +11370,13 @@ namespace sqlite_orm {
1136711370

1136811371
template<class T>
1136911372
using is_upsert_clause = polyfill::is_specialization_of<T, upsert_clause>;
11373+
#else
11374+
template<class T>
11375+
struct is_upsert_clause : polyfill::bool_constant<false> {};
11376+
#endif
1137011377
}
1137111378

11379+
#if SQLITE_VERSION_NUMBER >= 3024000
1137211380
/**
1137311381
* ON CONFLICT upsert clause builder function.
1137411382
* @example
@@ -12487,9 +12495,9 @@ namespace sqlite_orm {
1248712495
}
1248812496
};
1248912497

12490-
template<class... TargetArgs, class... ActionsArgs>
12491-
struct ast_iterator<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
12492-
using node_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
12498+
template<class T>
12499+
struct ast_iterator<T, match_if<is_upsert_clause, T>> {
12500+
using node_type = T;
1249312501

1249412502
template<class L>
1249512503
void operator()(const node_type& expression, L& lambda) const {
@@ -14293,13 +14301,13 @@ namespace sqlite_orm {
1429314301
(this->extract(values[Idx], std::get<Idx>(tuple)), ...);
1429414302
}
1429514303
#else
14296-
template<class Tpl, size_t I, size_t... Idx>
14297-
void operator()(sqlite3_value** values, Tpl& tuple, std::index_sequence<I, Idx...>) const {
14298-
this->extract(values[I], std::get<I>(tuple));
14299-
(*this)(values, tuple, std::index_sequence<Idx...>{});
14300-
}
14301-
template<class Tpl, size_t... Idx>
14302-
void operator()(sqlite3_value** /*values*/, Tpl&, std::index_sequence<Idx...>) const {}
14304+
template<class Tpl, size_t I, size_t... Idx>
14305+
void operator()(sqlite3_value** values, Tpl& tuple, std::index_sequence<I, Idx...>) const {
14306+
this->extract(values[I], std::get<I>(tuple));
14307+
(*this)(values, tuple, std::index_sequence<Idx...>{});
14308+
}
14309+
template<class Tpl, size_t... Idx>
14310+
void operator()(sqlite3_value** /*values*/, Tpl&, std::index_sequence<Idx...>) const {}
1430314311
#endif
1430414312
template<class T>
1430514313
void extract(sqlite3_value* value, T& t) const {
@@ -15675,9 +15683,9 @@ namespace sqlite_orm {
1567515683
}
1567615684
};
1567715685

15678-
template<class... TargetArgs, class... ActionsArgs>
15679-
struct statement_serializer<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void> {
15680-
using statement_type = upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>;
15686+
template<class T>
15687+
struct statement_serializer<T, match_if<is_upsert_clause, T>> {
15688+
using statement_type = T;
1568115689

1568215690
template<class Ctx>
1568315691
std::string operator()(const statement_type& statement, const Ctx& context) const {
@@ -18355,7 +18363,7 @@ namespace sqlite_orm {
1835518363
#if SQLITE_VERSION_NUMBER >= 3035000 // DROP COLUMN feature exists (v3.35.0)
1835618364
res = sync_schema_result::old_columns_removed;
1835718365
#else
18358-
gottaCreateTable = true;
18366+
gottaCreateTable = true;
1835918367
#endif
1836018368
} else {
1836118369
res = sync_schema_result::old_columns_removed;
@@ -18673,13 +18681,13 @@ namespace sqlite_orm {
1867318681
std::ref(processObject),
1867418682
std::ref(expression.transformer));
1867518683
#else
18676-
auto& transformer = expression.transformer;
18677-
std::for_each(expression.range.first,
18678-
expression.range.second,
18679-
[&processObject, &transformer](auto& item) {
18680-
const object_type& object = polyfill::invoke(transformer, item);
18681-
processObject(object);
18682-
});
18684+
auto& transformer = expression.transformer;
18685+
std::for_each(expression.range.first,
18686+
expression.range.second,
18687+
[&processObject, &transformer](auto& item) {
18688+
const object_type& object = polyfill::invoke(transformer, item);
18689+
processObject(object);
18690+
});
1868318691
#endif
1868418692
},
1868518693
[&processObject](auto& expression) {
@@ -18719,13 +18727,13 @@ namespace sqlite_orm {
1871918727
std::ref(processObject),
1872018728
std::ref(expression.transformer));
1872118729
#else
18722-
auto& transformer = expression.transformer;
18723-
std::for_each(expression.range.first,
18724-
expression.range.second,
18725-
[&processObject, &transformer](auto& item) {
18726-
const object_type& object = polyfill::invoke(transformer, item);
18727-
processObject(object);
18728-
});
18730+
auto& transformer = expression.transformer;
18731+
std::for_each(expression.range.first,
18732+
expression.range.second,
18733+
[&processObject, &transformer](auto& item) {
18734+
const object_type& object = polyfill::invoke(transformer, item);
18735+
processObject(object);
18736+
});
1872918737
#endif
1873018738
},
1873118739
[&processObject](auto& expression) {
@@ -18817,22 +18825,22 @@ namespace sqlite_orm {
1881718825
}
1881818826
return std::move(res).value();
1881918827
#else
18820-
auto& table = this->get_table<T>();
18821-
auto stepRes = sqlite3_step(stmt);
18822-
switch(stepRes) {
18823-
case SQLITE_ROW: {
18824-
T res;
18825-
object_from_column_builder<T> builder{res, stmt};
18826-
table.for_each_column(builder);
18827-
return res;
18828-
} break;
18829-
case SQLITE_DONE: {
18830-
throw std::system_error{orm_error_code::not_found};
18831-
} break;
18832-
default: {
18833-
throw_translated_sqlite_error(stmt);
18834-
}
18828+
auto& table = this->get_table<T>();
18829+
auto stepRes = sqlite3_step(stmt);
18830+
switch(stepRes) {
18831+
case SQLITE_ROW: {
18832+
T res;
18833+
object_from_column_builder<T> builder{res, stmt};
18834+
table.for_each_column(builder);
18835+
return res;
18836+
} break;
18837+
case SQLITE_DONE: {
18838+
throw std::system_error{orm_error_code::not_found};
18839+
} break;
18840+
default: {
18841+
throw_translated_sqlite_error(stmt);
1883518842
}
18843+
}
1883618844
#endif
1883718845
}
1883818846

@@ -19016,9 +19024,8 @@ namespace sqlite_orm {
1901619024
using type = tuple_cat_t<args_tuple, expression_tuple>;
1901719025
};
1901819026

19019-
template<class... TargetArgs, class... ActionsArgs>
19020-
struct node_tuple<upsert_clause<std::tuple<TargetArgs...>, std::tuple<ActionsArgs...>>, void>
19021-
: node_tuple<std::tuple<ActionsArgs...>> {};
19027+
template<class T>
19028+
struct node_tuple<T, match_if<is_upsert_clause, T>> : node_tuple<typename T::actions_tuple> {};
1902219029

1902319030
template<class... Args>
1902419031
struct node_tuple<set_t<Args...>, void> {
@@ -19659,9 +19666,9 @@ namespace sqlite_orm {
1965919666
#if __cpp_lib_ranges >= 201911L
1966019667
auto it = std::ranges::find(res, columnName, &table_xinfo::name);
1966119668
#else
19662-
auto it = std::find_if(res.begin(), res.end(), [&columnName](const table_xinfo& ti) {
19663-
return ti.name == columnName;
19664-
});
19669+
auto it = std::find_if(res.begin(), res.end(), [&columnName](const table_xinfo& ti) {
19670+
return ti.name == columnName;
19671+
});
1966519672
#endif
1966619673
if(it != res.end()) {
1966719674
it->pk = static_cast<int>(i + 1);
@@ -19734,9 +19741,9 @@ namespace sqlite_orm {
1973419741
}
1973519742
res = sync_schema_result::old_columns_removed;
1973619743
#else
19737-
// extra table columns than storage columns
19738-
this->backup_table(db, table, {});
19739-
res = sync_schema_result::old_columns_removed;
19744+
// extra table columns than storage columns
19745+
this->backup_table(db, table, {});
19746+
res = sync_schema_result::old_columns_removed;
1974019747
#endif
1974119748
}
1974219749

@@ -19800,11 +19807,11 @@ namespace sqlite_orm {
1980019807
#if __cpp_lib_ranges >= 201911L
1980119808
auto columnToIgnoreIt = std::ranges::find(columnsToIgnore, columnName, &table_xinfo::name);
1980219809
#else
19803-
auto columnToIgnoreIt = std::find_if(columnsToIgnore.begin(),
19804-
columnsToIgnore.end(),
19805-
[&columnName](const table_xinfo* tableInfo) {
19806-
return columnName == tableInfo->name;
19807-
});
19810+
auto columnToIgnoreIt = std::find_if(columnsToIgnore.begin(),
19811+
columnsToIgnore.end(),
19812+
[&columnName](const table_xinfo* tableInfo) {
19813+
return columnName == tableInfo->name;
19814+
});
1980819815
#endif
1980919816
if(columnToIgnoreIt == columnsToIgnore.end()) {
1981019817
columnNames.push_back(cref(columnName));

‎tests/ast_iterator_tests.cpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -207,12 +207,14 @@ TEST_CASE("ast_iterator") {
207207
expected.push_back(typeid(&User::id));
208208
iterate_ast(node, lambda);
209209
}
210+
#if SQLITE_VERSION_NUMBER >= 3024000
210211
SECTION("upsert_clause") {
211212
auto node = on_conflict(&User::id).do_update(set(c(&User::name) = excluded(&User::name)));
212213
expected.push_back(typeid(&User::name));
213214
expected.push_back(typeid(&User::name));
214215
iterate_ast(node, lambda);
215216
}
217+
#endif
216218
SECTION("into") {
217219
auto node = into<User>();
218220
iterate_ast(node, lambda);

‎tests/statement_serializer_tests/ast/upsert_clause.cpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
using namespace sqlite_orm;
55

6+
#if SQLITE_VERSION_NUMBER >= 3024000
67
TEST_CASE("upsert_clause") {
78
using internal::serialize;
89
struct Vocabulary {
@@ -102,3 +103,4 @@ TEST_CASE("upsert_clause") {
102103
}
103104
REQUIRE(value == expected);
104105
}
106+
#endif

‎tests/static_tests/node_tuple.cpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -925,13 +925,15 @@ TEST_CASE("Node tuple") {
925925
using ExpectedTuple = tuple<decltype(&User::id)>;
926926
STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
927927
}
928+
#if SQLITE_VERSION_NUMBER >= 3024000
928929
SECTION("upsert_clause") {
929930
auto statement = on_conflict(&User::id).do_update(set(c(&User::name) = excluded(&User::name)));
930931
using Statement = decltype(statement);
931932
using Tuple = node_tuple_t<Statement>;
932933
using ExpectedTuple = tuple<decltype(&User::name), decltype(&User::name)>;
933934
STATIC_REQUIRE(std::is_same<Tuple, ExpectedTuple>::value);
934935
}
936+
#endif
935937
SECTION("group_by") {
936938
auto statement = group_by(&User::id);
937939
using Statement = decltype(statement);

0 commit comments

Comments
 (0)