Inheritance diagram for database::integrated::transaction_impl:

Collaboration diagram for database::integrated::transaction_impl:

Public Member Functions
	transaction_impl (std::shared_ptr< core::database_backend > backend)

	~transaction_impl () override

kcenon::common::Result< query_result >	execute (const std::string &query, const std::vector< query_param > &params) override
	Execute a query within the transaction.

kcenon::common::VoidResult	commit () override
	Commit the transaction.

kcenon::common::VoidResult	rollback () override
	Rollback the transaction.

bool	is_active () const override
	Check if transaction is active.

Public Member Functions inherited from database::integrated::transaction
virtual	~transaction ()=default

Private Attributes
std::shared_ptr< core::database_backend >	backend_

bool	active_

Detailed Description

Definition at line 174 of file unified_database_system.cpp.

Constructor & Destructor Documentation

◆ transaction_impl()

database::integrated::transaction_impl::transaction_impl ( std::shared_ptr< core::database_backend > backend )

inlineexplicit

Definition at line 176 of file unified_database_system.cpp.

        : backend_(std::move(backend)), active_(false) {
 
        // Begin transaction
        if (backend_) {
            auto result = backend_->begin_transaction();
            if (result.is_ok()) {
                active_ = true;
            }
        }
    }

References active_, and backend_.

◆ ~transaction_impl()

database::integrated::transaction_impl::~transaction_impl ( )

inlineoverride

Definition at line 188 of file unified_database_system.cpp.

                                 {
        if (active_) {
            // Auto-rollback if not committed
            backend_->rollback_transaction();
        }
    }

References active_, and backend_.

Member Function Documentation

◆ commit()

kcenon::common::VoidResult database::integrated::transaction_impl::commit ( )

inlineoverridevirtual

Commit the transaction.

Returns: Success or error result

Implements database::integrated::transaction.

Definition at line 244 of file unified_database_system.cpp.

                                             {
        if (!active_) {
            return make_error("Transaction not active", -1, "transaction");
        }
 
        auto result = backend_->commit_transaction();
        if (result.is_err()) {
            return make_error("Commit failed: " + result.error().message, -1, "transaction");
        }
 
        active_ = false;
        return kcenon::common::ok();
    }

References active_, and backend_.

◆ execute()

kcenon::common::Result< query_result > database::integrated::transaction_impl::execute	(	const std::string &	query,
		const std::vector< query_param > &	params )

inlineoverridevirtual

Execute a query within the transaction.

Parameters

query	SQL query string
params	Optional query parameters

Returns: Result containing query results or error

Implements database::integrated::transaction.

Definition at line 195 of file unified_database_system.cpp.

                                                       {
 
        if (!active_) {
            return make_error_result<query_result>("Transaction not active", -1, "transaction");
        }
 
        auto start = std::chrono::steady_clock::now();
 
        kcenon::common::Result<core::database_result> db_result = [&]() {
            if (params.empty()) {
                if (is_select_query(query)) {
                    return backend_->select_query(query);
                }
                auto exec_res = backend_->execute_query(query);
                if (exec_res.is_err()) {
                    return kcenon::common::Result<core::database_result>(exec_res.error());
                }
                return kcenon::common::Result<core::database_result>(core::database_result{});
            }
            auto values = convert_params(params);
            if (is_select_query(query)) {
                return backend_->select_prepared(query, values);
            }
            auto exec_res = backend_->execute_prepared(query, values);
            if (exec_res.is_err()) {
                return kcenon::common::Result<core::database_result>(exec_res.error());
            }
            return kcenon::common::Result<core::database_result>(core::database_result{});
        }();
 
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::steady_clock::now() - start);
 
        if (db_result.is_err()) {
            return db_result.error();
        }
 
        auto qr = convert_result(db_result.value(), duration);
        // execute_query / execute_prepared return VoidResult (no row count),
        // so affected_rows stays 0 after convert_result.  For successful DML
        // queries we report at least 1 affected row.
        if (!is_select_query(query) && qr.affected_rows == 0) {
            qr.affected_rows = 1;
        }
        return qr;
    }

References active_, backend_, and database::integrated::convert_result().

Here is the call graph for this function:

◆ is_active()

bool database::integrated::transaction_impl::is_active ( ) const

inlineoverridevirtual

Check if transaction is active.

Returns: true if transaction is active

Implements database::integrated::transaction.

Definition at line 272 of file unified_database_system.cpp.

                                    {
        return active_;
    }

References active_.

◆ rollback()

kcenon::common::VoidResult database::integrated::transaction_impl::rollback ( )

inlineoverridevirtual

Rollback the transaction.

Returns: Success or error result

Implements database::integrated::transaction.

Definition at line 258 of file unified_database_system.cpp.

                                               {
        if (!active_) {
            return make_error("Transaction not active", -1, "transaction");
        }
 
        auto result = backend_->rollback_transaction();
        if (result.is_err()) {
            return make_error("Rollback failed: " + result.error().message, -1, "transaction");
        }
 
        active_ = false;
        return kcenon::common::ok();
    }