Add SELECT lock clauses and transaction statement builders

Author: Pierre-Luc Gagné

lib/include/ds_mysql/sql.hpp

@@ -4790,6 +4790,13 @@ struct alias_order_entry {
 
 using order_by_item = std::variant<std::string, alias_order_entry>;
 
+enum class select_lock_mode {
+    none,
+    for_update,
+    for_share,
+    lock_in_share_mode,
+};
+
 // ===================================================================
 // select_query_builder — unified builder for all SELECT clauses
 // ===================================================================
@@ -5072,6 +5079,36 @@ struct select_query_builder {
         return std::move(*this);
     }
 
+    [[nodiscard]] select_query_builder for_update() const& {
+        auto copy = *this;
+        copy.lock_mode_ = select_lock_mode::for_update;
+        return copy;
+    }
+    [[nodiscard]] select_query_builder for_update() && {
+        lock_mode_ = select_lock_mode::for_update;
+        return std::move(*this);
+    }
+
+    [[nodiscard]] select_query_builder for_share() const& {
+        auto copy = *this;
+        copy.lock_mode_ = select_lock_mode::for_share;
+        return copy;
+    }
+    [[nodiscard]] select_query_builder for_share() && {
+        lock_mode_ = select_lock_mode::for_share;
+        return std::move(*this);
+    }
+
+    [[nodiscard]] select_query_builder lock_in_share_mode() const& {
+        auto copy = *this;
+        copy.lock_mode_ = select_lock_mode::lock_in_share_mode;
+        return copy;
+    }
+    [[nodiscard]] select_query_builder lock_in_share_mode() && {
+        lock_mode_ = select_lock_mode::lock_in_share_mode;
+        return std::move(*this);
+    }
+
     // ---- JOIN clauses ----
     //
     // Use col<Table, Index> descriptors for the join columns to produce
@@ -5266,6 +5303,13 @@ struct select_query_builder {
             sql += " OFFSET ";
             sql += std::to_string(*offset_);
         }
+        if (lock_mode_ == select_lock_mode::for_update) {
+            sql += " FOR UPDATE";
+        } else if (lock_mode_ == select_lock_mode::for_share) {
+            sql += " FOR SHARE";
+        } else if (lock_mode_ == select_lock_mode::lock_in_share_mode) {
+            sql += " LOCK IN SHARE MODE";
+        }
         return sql;
     }
 
@@ -5318,6 +5362,7 @@ struct select_query_builder {
     std::vector<order_by_item> order_by_clauses_;
     std::optional<std::size_t> limit_;
     std::optional<std::size_t> offset_;
+    select_lock_mode lock_mode_ = select_lock_mode::none;
     bool distinct_ = false;
     std::string joins_;
     std::map<std::size_t, std::string> aliases_;
@@ -5380,6 +5425,19 @@ class union_query {
     std::string sql_;
 };
 
+class statement_query {
+public:
+    explicit statement_query(std::string sql) : sql_(std::move(sql)) {
+    }
+
+    [[nodiscard]] std::string build_sql() const {
+        return sql_;
+    }
+
+private:
+    std::string sql_;
+};
+
 }  // namespace detail
 
 // ===================================================================
@@ -5418,6 +5476,22 @@ template <TypedSelectQuery Q1, TypedSelectQuery Q2>
                                                              ")"};
 }
 
+[[nodiscard]] inline detail::statement_query start_transaction() {
+    return detail::statement_query{"START TRANSACTION"};
+}
+
+[[nodiscard]] inline detail::statement_query begin_transaction() {
+    return detail::statement_query{"BEGIN"};
+}
+
+[[nodiscard]] inline detail::statement_query commit_transaction() {
+    return detail::statement_query{"COMMIT"};
+}
+
+[[nodiscard]] inline detail::statement_query rollback_transaction() {
+    return detail::statement_query{"ROLLBACK"};
+}
+
 /**
  * select<Projs...>() — begin a type-safe SELECT query.
  *

tests/unit/test_dml.cpp

@@ -16,14 +16,14 @@ using namespace std::string_literals;
 
 namespace {
 struct asset {
-    COLUMN_FIELD(id,                uint32_t)
-    COLUMN_FIELD(exchange_id,       std::optional<uint32_t>)
-    COLUMN_FIELD(ticker,            varchar_field<32>)
-    COLUMN_FIELD(instrument,        varchar_field<64>)
-    COLUMN_FIELD(name,              std::optional<varchar_field<255>>)
-    COLUMN_FIELD(sector,            std::optional<varchar_field<255>>)
-    COLUMN_FIELD(currency,          std::optional<varchar_field<32>>)
-    COLUMN_FIELD(created_date,      sql_datetime)
+    COLUMN_FIELD(id, uint32_t)
+    COLUMN_FIELD(exchange_id, std::optional<uint32_t>)
+    COLUMN_FIELD(ticker, varchar_field<32>)
+    COLUMN_FIELD(instrument, varchar_field<64>)
+    COLUMN_FIELD(name, std::optional<varchar_field<255>>)
+    COLUMN_FIELD(sector, std::optional<varchar_field<255>>)
+    COLUMN_FIELD(currency, std::optional<varchar_field<32>>)
+    COLUMN_FIELD(created_date, sql_datetime)
     COLUMN_FIELD(last_updated_date, sql_datetime)
 };
 }  // namespace
@@ -42,6 +42,26 @@ suite<"DML"> dml_suite = [] {
         expect(sql == "DESCRIBE asset"s) << sql;
     };
 
+    "start_transaction - generates correct SQL"_test = [] {
+        auto const sql = start_transaction().build_sql();
+        expect(sql == "START TRANSACTION"s) << sql;
+    };
+
+    "begin_transaction - generates correct SQL"_test = [] {
+        auto const sql = begin_transaction().build_sql();
+        expect(sql == "BEGIN"s) << sql;
+    };
+
+    "commit_transaction - generates correct SQL"_test = [] {
+        auto const sql = commit_transaction().build_sql();
+        expect(sql == "COMMIT"s) << sql;
+    };
+
+    "rollback_transaction - generates correct SQL"_test = [] {
+        auto const sql = rollback_transaction().build_sql();
+        expect(sql == "ROLLBACK"s) << sql;
+    };
+
     // -------------------------------------------------------------------
     // insert_into<T>
     // -------------------------------------------------------------------
@@ -311,8 +331,10 @@ suite<"DML"> dml_suite = [] {
         row.exchange_id_ = 1u;
         row.ticker_ = "AAPL";
         row.instrument_ = "Stock";
-        auto const sql =
-            insert_into<asset>().values(row).on_duplicate_key_update(asset::ticker{"AAPL"}, asset::instrument{"Stock"}).build_sql();
+        auto const sql = insert_into<asset>()
+                             .values(row)
+                             .on_duplicate_key_update(asset::ticker{"AAPL"}, asset::instrument{"Stock"})
+                             .build_sql();
         expect(sql ==
                "INSERT INTO asset (id, exchange_id, ticker, instrument, name, sector, currency, created_date, "
                "last_updated_date) "

tests/unit/test_dql.cpp

@@ -102,8 +102,9 @@ suite<"DQL"> dql_suite = [] {
                              .order_by<product::id>()
                              .limit(3)
                              .build_sql();
-        expect(sql ==
-               "SELECT id, category_id, sku, type, name, tag, unit, created_at, last_updated_at FROM product ORDER BY id ASC LIMIT 3"s)
+        expect(
+            sql ==
+            "SELECT id, category_id, sku, type, name, tag, unit, created_at, last_updated_at FROM product ORDER BY id ASC LIMIT 3"s)
             << sql;
     };
 
@@ -330,6 +331,26 @@ suite<"DQL Extended Clauses"> dql_extended_clauses_suite = [] {
             << sql;
     };
 
+    "for_update - appends FOR UPDATE lock clause"_test = [] {
+        auto const sql = select<product::id>().from<product>().where(equal<product::id>(1u)).for_update().build_sql();
+        expect(sql == "SELECT id FROM product WHERE id = 1 FOR UPDATE"s) << sql;
+    };
+
+    "for_share - appends FOR SHARE lock clause"_test = [] {
+        auto const sql = select<product::id>().from<product>().order_by<product::id>().for_share().build_sql();
+        expect(sql == "SELECT id FROM product ORDER BY id ASC FOR SHARE"s) << sql;
+    };
+
+    "lock_in_share_mode - appends LOCK IN SHARE MODE lock clause"_test = [] {
+        auto const sql = select<product::id>().from<product>().limit(5).lock_in_share_mode().build_sql();
+        expect(sql == "SELECT id FROM product LIMIT 5 LOCK IN SHARE MODE"s) << sql;
+    };
+
+    "lock clause precedence - last lock method wins"_test = [] {
+        auto const sql = select<product::id>().from<product>().for_update().for_share().build_sql();
+        expect(sql == "SELECT id FROM product FOR SHARE"s) << sql;
+    };
+
     "union_ - combines two queries with UNION"_test = [] {
         auto const q1 = select<product::id>().from<product>().where(equal<product::type>("gadget"));
         auto const q2 = select<product::id>().from<product>().where(equal<product::type>("widget"));