transaction.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/storages/sqlite/transaction.hpp
 
#include <userver/utils/fast_pimpl.hpp>
 
#include <userver/storages/sqlite/cursor_result_set.hpp>
#include <userver/storages/sqlite/impl/binder_help.hpp>
#include <userver/storages/sqlite/options.hpp>
#include <userver/storages/sqlite/query.hpp>
#include <userver/storages/sqlite/result_set.hpp>
#include <userver/storages/sqlite/savepoint.hpp>
#include <userver/storages/sqlite/sqlite_fwd.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace storages::sqlite {
 
/// @brief RAII transaction wrapper, auto-<b>ROLLBACK</b>s on destruction if no
/// prior `Commit`/`Rollback` call was made.
///
/// This type can't be constructed in user code and is always retrieved from
/// storages::sqlite::Client
class Transaction final {
public:
    Transaction(std::shared_ptr<infra::ConnectionPtr> connection, const settings::TransactionOptions& options);
    ~Transaction();
    Transaction(const Transaction& other) = delete;
    Transaction(Transaction&& other) noexcept;
    Transaction& operator=(Transaction&&) noexcept;
 
    /// @brief Executes a statement.
    ///
    /// Fills placeholders of the statement with args..., `Args` are expected to
    /// be of supported types.
    /// See @ref scripts/docs/en/userver/sqlite/supported_types.md for better understanding of `Args`
    /// requirements.
    ///
    /// @tparam Args Types of parameters to bind
    /// @param query SQL query to execute
    /// @param args Parameters to bind to the query
    /// @return ResultSet containing the results of the query
    template <typename... Args>
    ResultSet Execute(const Query& query, const Args&... args) const;
 
    /// @brief Executes a statement, decomposing the row.
    ///
    /// Decomposes the fields of the row and binds them as parameters to the query.
    /// See @ref scripts/docs/en/userver/sqlite/supported_types.md for better understanding of `T` requirements.
    ///
    /// @tparam T Type of the row to decompose
    /// @param query SQL query to execute
    /// @param row Row object to decompose and bind
    /// @return ResultSet containing the results of the query
    template <typename T>
    ResultSet ExecuteDecompose(const Query& query, const T& row) const;
 
    /// @brief Executes a statement multiple times.
    ///
    /// Iterates over the container and executes the query for each element.
    /// Container is expected to be a std::Container, Container::value_type is
    /// expected to be an aggregate of supported types.
    /// See @ref scripts/docs/en/userver/mysql/supported_types.md for better understanding of
    /// `Container::value_type` requirements.
    ///
    /// @tparam Container Type of the container holding rows
    /// @param query SQL query to execute
    /// @param params Container of rows to bind and execute
    template <typename Container>
    void ExecuteMany(const Query& query, const Container& params) const;
 
    /// @brief Executes a statement and returns a cursor for iterating over results.
    ///
    /// Fills placeholders of the statement with args..., `Args` are expected to
    /// be of supported types.
    /// See @ref scripts/docs/en/userver/sqlite/supported_types.md for better understanding of `Args`
    /// requirements.
    ///
    /// @tparam T Type of the result rows
    /// @tparam Args Types of parameters to bind
    /// @param batch_size Number of rows to fetch per batch
    /// @param query SQL query to execute
    /// @param args Parameters to bind to the query
    /// @return CursorResultSet for iterating over the results
    template <typename T, typename... Args>
    CursorResultSet<T> GetCursor(std::size_t batch_size, const Query& query, const Args&... args) const;
 
    /// @brief Creates a savepoint with specified name.
    ///
    /// @param name Name of the savepoint
    /// @return Savepoint object representing the created savepoint
    Savepoint Save(std::string name) const;
 
    /// @brief Commit the transaction
    void Commit();
 
    /// @brief Rollback the transaction
    void Rollback();
 
private:
    ResultSet DoExecute(impl::io::ParamsBinderBase& params) const;
    void AssertValid() const;
 
    void AccountQueryExecute() const noexcept;
    void AccountQueryFailed() const noexcept;
 
    std::shared_ptr<infra::ConnectionPtr> connection_;
};
class Transaction final {…};
 
template <typename... Args>
ResultSet Transaction::Execute(const Query& query, const Args&... args) const {
    AssertValid();
    AccountQueryExecute();
    try {
        auto params_binder = impl::BindHelper::UpdateParamsBindings(query.GetStatement(), *connection_, args...);
        return DoExecute(params_binder);
    } catch (const std::exception& err) {
        AccountQueryFailed();
        throw;
    }
}
ResultSet Transaction::Execute(const Query& query, const Args&... args) const {…}
 
template <typename T>
ResultSet Transaction::ExecuteDecompose(const Query& query, const T& row) const {
    AssertValid();
    AccountQueryExecute();
    try {
        auto params_binder = impl::BindHelper::UpdateRowAsParamsBindings(query.GetStatement(), *connection_, row);
        return DoExecute(params_binder);
    } catch (const std::exception& err) {
        AccountQueryFailed();
        throw;
    }
}
ResultSet Transaction::ExecuteDecompose(const Query& query, const T& row) const {…}
 
template <typename Container>
void Transaction::ExecuteMany(const Query& query, const Container& params) const {
    AssertValid();
    AccountQueryExecute();
    for (const auto& row : params) {
        try {
            auto params_binder = impl::BindHelper::UpdateRowAsParamsBindings(query.GetStatement(), *connection_, row);
            DoExecute(params_binder);
        } catch (const std::exception& err) {
            AccountQueryFailed();
            throw;
        }
    }
}
void Transaction::ExecuteMany(const Query& query, const Container& params) const {…}
 
template <typename T, typename... Args>
CursorResultSet<T> Transaction::GetCursor(std::size_t batch_size, const Query& query, const Args&... args) const {
    AssertValid();
    AccountQueryExecute();
    try {
        auto params_binder = impl::BindHelper::UpdateParamsBindings(query.GetStatement(), *connection_, args...);
        return CursorResultSet<T>{DoExecute(params_binder, connection_), batch_size};
    } catch (const std::exception& err) {
        AccountQueryFailed();
        throw;
    }
}
CursorResultSet<T> Transaction::GetCursor(std::size_t batch_size, const Query& query, const Args&... args) const {…}
 
}  // namespace storages::sqlite
 
USERVER_NAMESPACE_END