Implement insert_or_replace

.github/workflows/linux-cxx20-conan.yaml

@@ -1,6 +1,6 @@
 name: linux-cxx20-conan
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   linux:

.github/workflows/linux-cxx20-vcpkg.yaml

@@ -1,6 +1,6 @@
 name: linux-cxx20-vcpkg 
 
-on: [push]
+on: [push, pull_request]
 
 env: 
     VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"

.github/workflows/macos-cxx20-conan.yaml

@@ -1,6 +1,6 @@
 name: macos-cxx20-conan
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   macos-clang:

.github/workflows/macos-cxx20-vcpkg.yaml

@@ -1,6 +1,6 @@
 name: macos-cxx20-vcpkg
 
-on: [push]
+on: [push, pull_request]
 
 env: 
     VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"
@@ -57,6 +57,7 @@ jobs:
           if [[ "${{ matrix.os == 'macos-latest' }}" == "true" ]]; then
             export VCPKG_FORCE_SYSTEM_BINARIES=arm
             export CMAKE_GENERATOR=Ninja
+            export MACOSX_DEPLOYMENT_TARGET="$(sw_vers -productVersion)"
           fi
           $CXX --version
           cmake -S . -B build -G Ninja -DCMAKE_CXX_STANDARD=20 -DSQLGEN_BUILD_TESTS=ON -DSQLGEN_SQLITE3=OFF -DSQLGEN_BUILD_DRY_TESTS_ONLY=ON 

.github/workflows/windows-cxx20-vcpkg.yaml

@@ -1,6 +1,6 @@
 name: windows-cxx20-vcpkg 
 
-on: [push]
+on: [push, pull_request]
 
 env: 
     VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite"

docs/insert.md

@@ -68,6 +68,58 @@ sqlgen::sqlite::connect("database.db")
     .value();
 ```
 
+### With Replacement
+
+Replace existing rows:
+
+```cpp
+const auto people1 = std::vector<Person>({
+    Person{.id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
+    Person{.id = 1, .first_name = "Bart", .last_name = "Simpson", .age = 10}
+});
+
+const auto people2 = std::vector<Person>({
+    Person{.id = 1, .first_name = "Bartholomew", .last_name = "Simpson", .age = 10}
+});
+
+using namespace sqlgen;
+
+const auto result = sqlite::connect()
+    .and_then(create_table<Person> | if_not_exists)
+    .and_then(insert(std::ref(people1)))
+    .and_then(insert_or_replace(std::ref(people2)))
+    .value();
+```
+
+This generates the following SQL:
+
+```sql
+CREATE TABLE IF NOT EXISTS "Person" (
+    "id" INTEGER PRIMARY KEY,
+    "first_name" TEXT NOT NULL,
+    "last_name" TEXT NOT NULL,
+    "age" INTEGER NOT NULL
+);
+INSERT INTO "Person" ("id", "first_name", "last_name", "age") VALUES (?, ?, ?, ?);
+INSERT INTO "Person" ("id", "first_name", "last_name", "age") VALUES (?, ?, ?, ?)
+ON CONFLICT (id) DO UPDATE SET
+  id=excluded.id,
+  first_name=excluded.first_name,
+  last_name=excluded.last_name,
+  age=excluded.age;
+```
+
+The SQL generated by the PostgreSQL backend for `insert_or_replace(...)` is similar. The MySQL backend generates `ON DUPLICATE KEY UPDATE` instead:
+```sql
+...
+INSERT INTO `Person` (`id`, `first_name`, `last_name`, `age`) VALUES (?, ?, ?, ?)
+ON DUPLICATE KEY UPDATE
+  id=VALUES(id),
+  first_name=VALUES(first_name),
+  last_name=VALUES(last_name),
+  age=VALUES(age);
+```
+
 ## Example: Full Transaction Usage
 
 Here's a complete example showing how to use `insert` within a transaction:
@@ -195,5 +247,4 @@ While both `insert` and `write` can be used to add data to a database, they serv
   4. Takes a connection and a reference wrapper to a container
 - Unlike `write`, `insert` does not create tables automatically - you must create tables separately using `create_table`
 - The insert operation is atomic within a transaction
-- When using reference wrappers (`std::ref`), the data is not copied, which can be more efficient for large datasets
-
+- When using reference wrappers (`std::ref`), the data is not copied, which can be more efficient for large datasets

include/sqlgen/dynamic/Insert.hpp

@@ -11,6 +11,11 @@ namespace sqlgen::dynamic {
 struct Insert {
   Table table;
   std::vector<std::string> columns;
+  bool or_replace;
+  std::vector<std::string> non_primary_keys;
+
+  /// Holds primary keys and unique columns when or_replace is true.
+  std::vector<std::string> constraints;
 };
 
 }  // namespace sqlgen::dynamic

include/sqlgen/insert.hpp

@@ -7,9 +7,11 @@
 #include <rfl.hpp>
 #include <string>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "internal/batch_size.hpp"
+#include "internal/has_constraint.hpp"
 #include "internal/to_str_vec.hpp"
 #include "is_connection.hpp"
 #include "transpilation/to_insert_or_write.hpp"
@@ -18,13 +20,14 @@ namespace sqlgen {
 
 template <class ItBegin, class ItEnd, class Connection>
   requires is_connection<Connection>
-Result<Ref<Connection>> insert(const Ref<Connection>& _conn, ItBegin _begin,
-                               ItEnd _end) {
+Result<Ref<Connection>> insert_impl(const Ref<Connection>& _conn,
+                                    ItBegin _begin, ItEnd _end,
+                                    bool _or_replace) {
   using T =
       std::remove_cvref_t<typename std::iterator_traits<ItBegin>::value_type>;
 
   const auto insert_stmt =
-      transpilation::to_insert_or_write<T, dynamic::Insert>();
+      transpilation::to_insert_or_write<T, dynamic::Insert>(_or_replace);
 
   std::vector<std::vector<std::optional<std::string>>> data;
 
@@ -51,40 +54,82 @@ Result<Ref<Connection>> insert(const Ref<Connection>& _conn, ItBegin _begin,
 
 template <class ItBegin, class ItEnd, class Connection>
   requires is_connection<Connection>
-Result<Ref<Connection>> insert(const Result<Ref<Connection>>& _res,
-                               ItBegin _begin, ItEnd _end) {
-  return _res.and_then(
-      [&](const auto& _conn) { return insert(_conn, _begin, _end); });
+Result<Ref<Connection>> insert_impl(const Result<Ref<Connection>>& _res,
+                                    ItBegin _begin, ItEnd _end,
+                                    bool _or_replace) {
+  return _res.and_then([&](const auto& _conn) {
+    return insert_impl(_conn, _begin, _end, _or_replace);
+  });
 }
 
 template <class ContainerType>
-auto insert(const auto& _conn, const ContainerType& _data) {
+auto insert_impl(const auto& _conn, const ContainerType& _data,
+                 bool _or_replace) {
   if constexpr (std::ranges::input_range<std::remove_cvref_t<ContainerType>>) {
-    return insert(_conn, _data.begin(), _data.end());
+    return insert_impl(_conn, _data.begin(), _data.end(), _or_replace);
   } else {
-    return insert(_conn, &_data, &_data + 1);
+    return insert_impl(_conn, &_data, &_data + 1, _or_replace);
   }
 }
 
 template <class ContainerType>
-auto insert(const auto& _conn,
-            const std::reference_wrapper<ContainerType>& _data) {
-  return insert(_conn, _data.get());
+auto insert_impl(const auto& _conn,
+                 const std::reference_wrapper<ContainerType>& _data,
+                 bool _or_replace) {
+  return insert_impl(_conn, _data.get(), _or_replace);
 }
 
 template <class ContainerType>
 struct Insert {
-  auto operator()(const auto& _conn) const { return insert(_conn, data_); }
+  auto operator()(const auto& _conn) const {
+    return insert_impl(_conn, data_, or_replace_);
+  }
 
   ContainerType data_;
+  bool or_replace_;
 };
 
 template <class ContainerType>
-Insert<ContainerType> insert(const ContainerType& _data) {
-  return Insert<ContainerType>{.data_ = _data};
+Insert<ContainerType> insert_impl(const ContainerType& _data,
+                                  bool _or_replace) {
+  return Insert<ContainerType>{.data_ = _data, .or_replace_ = _or_replace};
+}
+
+template <class... Args>
+auto insert(const Args&... args) {
+  return insert_impl(args..., false);
+}
+
+template <class ContainerType>
+auto insert_or_replace(const auto& _conn, const ContainerType& _data) {
+  if constexpr (std::ranges::input_range<std::remove_cvref_t<ContainerType>>) {
+    static_assert(
+        internal::has_constraint_v<typename ContainerType::value_type>,
+        "The table must have a primary key or unique column for "
+        "insert_or_replace(...) to work.");
+  } else {
+    static_assert(internal::has_constraint_v<ContainerType>,
+                  "The table must have a primary key or unique column for "
+                  "insert_or_replace(...) to work.");
+  }
+  return insert_impl(_conn, _data, true);
+}
+
+template <class ContainerType>
+auto insert_or_replace(const ContainerType& _data) {
+  if constexpr (std::ranges::input_range<std::remove_cvref_t<ContainerType>>) {
+    static_assert(
+        internal::has_constraint_v<typename ContainerType::value_type>,
+        "The table must have a primary key or unique column for "
+        "insert_or_replace(...) to work.");
+  } else {
+    static_assert(internal::has_constraint_v<ContainerType>,
+                  "The table must have a primary key or unique column for "
+                  "insert_or_replace(...) to work.");
+  }
+  return insert_impl(_data, true);
 }
 
 };  // namespace sqlgen
 
 #endif
-

include/sqlgen/internal/has_constraint.hpp

@@ -0,0 +1,24 @@
+#ifndef SQLGEN_INTERNAL_HAS_CONSTRAINT_HPP_
+#define SQLGEN_INTERNAL_HAS_CONSTRAINT_HPP_
+
+#include <type_traits>
+
+#include "is_constraint.hpp"
+
+namespace sqlgen::internal {
+
+template <class T>
+struct has_constraint;
+
+template <class... FieldTypes>
+struct has_constraint<rfl::NamedTuple<FieldTypes...>> {
+  constexpr static bool value =
+      (false || ... || is_constraint_v<typename FieldTypes::Type>);
+};
+
+template <class T>
+constexpr bool has_constraint_v = has_constraint<rfl::named_tuple_t<T>>::value;
+
+}  // namespace sqlgen::internal
+
+#endif

include/sqlgen/internal/has_primary_key.hpp

@@ -0,0 +1,25 @@
+#ifndef SQLGEN_INTERNAL_HAS_PRIMARY_KEY_HPP_
+#define SQLGEN_INTERNAL_HAS_PRIMARY_KEY_HPP_
+
+#include <rfl.hpp>
+
+#include "is_primary_key.hpp"
+
+namespace sqlgen::internal {
+
+template <class T>
+struct has_primary_key;
+
+template <class... FieldTypes>
+struct has_primary_key<rfl::NamedTuple<FieldTypes...>> {
+  constexpr static bool value =
+      (false || ... || is_primary_key_v<typename FieldTypes::Type>);
+};
+
+template <class T>
+constexpr bool has_primary_key_v =
+    has_primary_key<rfl::named_tuple_t<T>>::value;
+
+}  // namespace sqlgen::internal
+
+#endif

include/sqlgen/internal/has_unique_column.hpp

@@ -0,0 +1,25 @@
+#ifndef SQLGEN_INTERNAL_HAS_UNIQUE_COLUMN_HPP_
+#define SQLGEN_INTERNAL_HAS_UNIQUE_COLUMN_HPP_
+
+#include <rfl.hpp>
+
+#include "is_unique_column.hpp"
+
+namespace sqlgen::internal {
+
+template <class T>
+struct has_unique_column;
+
+template <class... FieldTypes>
+struct has_unique_column<rfl::NamedTuple<FieldTypes...>> {
+  constexpr static bool value =
+      (false || ... || is_unique_column_v<typename FieldTypes::Type>);
+};
+
+template <class T>
+constexpr bool has_unique_column_v =
+    has_unique_column<rfl::named_tuple_t<T>>::value;
+
+}  // namespace sqlgen::internal
+
+#endif

include/sqlgen/internal/is_constraint.hpp

@@ -0,0 +1,19 @@
+#ifndef SQLGEN_INTERNAL_IS_CONSTRAINT_HPP_
+#define SQLGEN_INTERNAL_IS_CONSTRAINT_HPP_
+
+#include <type_traits>
+
+#include "is_primary_key.hpp"
+#include "is_unique_column.hpp"
+
+namespace sqlgen::internal {
+
+template <class T>
+using is_constraint = std::disjunction<is_primary_key<T>, is_unique_column<T>>;
+
+template <class T>
+constexpr bool is_constraint_v = is_constraint<std::remove_cvref_t<T>>();
+
+}  // namespace sqlgen::internal
+
+#endif

include/sqlgen/internal/is_primary_key.hpp

@@ -0,0 +1,24 @@
+#ifndef SQLGEN_INTERNAL_IS_PRIMARY_KEY_HPP_
+#define SQLGEN_INTERNAL_IS_PRIMARY_KEY_HPP_
+
+#include <type_traits>
+
+#include "../PrimaryKey.hpp"
+
+namespace sqlgen::internal {
+
+template <class T>
+class is_primary_key;
+
+template <class T>
+class is_primary_key : public std::false_type {};
+
+template <class T, bool _auto_incr>
+class is_primary_key<PrimaryKey<T, _auto_incr>> : public std::true_type {};
+
+template <class T>
+constexpr bool is_primary_key_v = is_primary_key<std::remove_cvref_t<T>>();
+
+}  // namespace sqlgen::internal
+
+#endif