Manages entity metadata and provides factory methods. More...

#include <entity.h>

Collaboration diagram for database::orm::entity_manager:

Public Member Functions
	entity_manager ()=default
	Default constructor - used by database_context.

template<typename EntityType >
std::enable_if_t< is_entity_v< EntityType > >	register_entity ()

template<typename EntityType >
std::enable_if_t< is_entity_v< EntityType >, const entity_metadata & >	get_metadata ()

template<typename EntityType >
std::enable_if_t< is_entity_v< EntityType >, query_builder< EntityType > >	query (std::shared_ptr< core::database_backend > db)

bool	create_tables (std::shared_ptr< core::database_backend > db)

bool	drop_tables (std::shared_ptr< core::database_backend > db)

bool	sync_schema (std::shared_ptr< core::database_backend > db)

Private Attributes
std::unordered_map< std::string, std::unique_ptr< entity_metadata > >	metadata_cache_

Detailed Description

Manages entity metadata and provides factory methods.

Note: This class uses dependency injection pattern. Access via database_context::get_entity_manager() (Sprint 3, Task 3.1).

Definition at line 246 of file entity.h.

Constructor & Destructor Documentation

◆ entity_manager()

database::orm::entity_manager::entity_manager ( )

default

Default constructor - used by database_context.

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

Member Function Documentation

◆ create_tables()

bool database::orm::entity_manager::create_tables ( std::shared_ptr< core::database_backend > db )

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

Definition at line 166 of file entity.cpp.

    {
        if (!db) {
            ORM_LOG_ERROR("create_tables", "Database connection is null");
            return false;
        }
 
        try {
            for (const auto& [name, metadata] : metadata_cache_) {
                // Create table
                std::string create_sql = metadata->create_table_sql();
                auto result = db->execute_query(create_sql);
                if (result.is_err()) {
                    ORM_LOG_ERROR("create_tables", "Failed to create table: " + name);
                    return false;
                }
 
                // Create indexes
                std::string index_sql = metadata->create_indexes_sql();
                if (!index_sql.empty()) {
                    auto index_result = db->execute_query(index_sql);
                    if (index_result.is_err()) {
                        ORM_LOG_ERROR("create_tables", "Failed to create indexes for table: " + name);
                        return false;
                    }
                }
            }
            return true;
        } catch (const std::exception& e) {
            ORM_LOG_ERROR("create_tables", std::string("Exception during table creation: ") + e.what());
            return false;
        }
    }

References metadata_cache_, and ORM_LOG_ERROR.

Referenced by sync_schema().

Here is the caller graph for this function:

◆ drop_tables()

bool database::orm::entity_manager::drop_tables ( std::shared_ptr< core::database_backend > db )

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

Definition at line 200 of file entity.cpp.

    {
        if (!db) {
            ORM_LOG_ERROR("drop_tables", "Database connection is null");
            return false;
        }
 
        try {
            for (const auto& [name, metadata] : metadata_cache_) {
                std::string drop_sql = "DROP TABLE IF EXISTS " + metadata->table_name();
                auto result = db->execute_query(drop_sql);
                if (result.is_err()) {
                    ORM_LOG_ERROR("drop_tables", "Failed to drop table: " + name);
                    return false;
                }
            }
            return true;
        } catch (const std::exception& e) {
            ORM_LOG_ERROR("drop_tables", std::string("Exception during table dropping: ") + e.what());
            return false;
        }
    }

References metadata_cache_, and ORM_LOG_ERROR.

Referenced by sync_schema().

Here is the caller graph for this function:

◆ get_metadata()

template<typename EntityType >

std::enable_if_t< is_entity_v< EntityType >, const entity_metadata & > database::orm::entity_manager::get_metadata ( )

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

◆ query()

template<typename EntityType >

std::enable_if_t< is_entity_v< EntityType >, query_builder< EntityType > > database::orm::entity_manager::query ( std::shared_ptr< core::database_backend > db )

◆ register_entity()

template<typename EntityType >

std::enable_if_t< is_entity_v< EntityType > > database::orm::entity_manager::register_entity ( )

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

Referenced by IntegrationTestBase::setup_orm_framework().

Here is the caller graph for this function:

◆ sync_schema()

bool database::orm::entity_manager::sync_schema ( std::shared_ptr< core::database_backend > db )

Examples: /home/runner/work/database_system/database_system/database/orm/entity.h.

Definition at line 223 of file entity.cpp.

    {
        if (!db) {
            ORM_LOG_ERROR("sync_schema", "Database connection is null");
            return false;
        }
 
        try {
            // For now, just recreate all tables
            // In a real implementation, this would do schema diffing
            if (!drop_tables(db)) {
                ORM_LOG_ERROR("sync_schema", "Failed to drop existing tables");
                return false;
            }
 
            if (!create_tables(db)) {
                ORM_LOG_ERROR("sync_schema", "Failed to create new tables");
                return false;
            }
 
            return true;
        } catch (const std::exception& e) {
            ORM_LOG_ERROR("sync_schema", std::string("Exception during schema sync: ") + e.what());
            return false;
        }
    }