orm_entity_demo.cpp File Reference

Demonstrates the ORM entity system with field metadata and SQL generation. More...

#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include "database/orm/entity.h"
#include "database/database_types.h"

Include dependency graph for orm_entity_demo.cpp:

Go to the source code of this file.

Classes
class	user_entity
class	post_entity

Functions
int	main ()

Detailed Description

Demonstrates the ORM entity system with field metadata and SQL generation.

This example shows how to:

• Define an entity class deriving from entity_base
• Configure field constraints (primary key, not null, unique, index)
• Generate CREATE TABLE SQL from entity metadata
• Inspect entity field metadata programmatically
• Use type-safe field accessors
• Check type traits for entity and field types

Note: This example focuses on the ORM metadata and schema generation capabilities. It does not require a running database.

Definition in file orm_entity_demo.cpp.

Function Documentation

main()

int main

(

)

Definition at line 117 of file orm_entity_demo.cpp.

{
    std::cout << "=== orm_entity_demo example ===" << std::endl;
 
    // -------------------------------------------------------
    // 1. Inspect User entity metadata
    // -------------------------------------------------------
    std::cout << "\n--- User entity metadata ---" << std::endl;
    {
        user_entity user;
        const auto& meta = user.get_metadata();
 
        std::cout << "Table: " << meta.table_name() << std::endl;
        std::cout << "Fields:" << std::endl;
 
        for (const auto& field : meta.fields())
        {
            std::cout << "  " << field.name()
                      << " (" << field.type_name() << ")";
 
            if (field.is_primary_key())
            {
                std::cout << " [PK]";
            }
            if (field.is_auto_increment())
            {
                std::cout << " [AUTO]";
            }
            if (field.is_not_null())
            {
                std::cout << " [NOT NULL]";
            }
            if (field.is_unique())
            {
                std::cout << " [UNIQUE]";
            }
            if (field.has_index())
            {
                std::cout << " [INDEX]";
            }
            std::cout << std::endl;
        }
 
        // Primary key info
        const auto* pk = meta.get_primary_key();
        if (pk != nullptr)
        {
            std::cout << "Primary key: " << pk->name() << std::endl;
        }
    }
 
    // -------------------------------------------------------
    // 2. Generate CREATE TABLE SQL
    // -------------------------------------------------------
    std::cout << "\n--- Generated SQL ---" << std::endl;
    {
        user_entity user;
        std::cout << "User table SQL:" << std::endl;
        std::cout << user.get_metadata().create_table_sql() << std::endl;
 
        post_entity post;
        std::cout << "\nPost table SQL:" << std::endl;
        std::cout << post.get_metadata().create_table_sql() << std::endl;
    }
 
    // -------------------------------------------------------
    // 3. Generate index SQL
    // -------------------------------------------------------
    std::cout << "\n--- Generated index SQL ---" << std::endl;
    {
        post_entity post;
        auto index_sql = post.get_metadata().create_indexes_sql();
        if (!index_sql.empty())
        {
            std::cout << "Post indexes:" << std::endl;
            std::cout << index_sql << std::endl;
        }
        else
        {
            std::cout << "No additional indexes defined" << std::endl;
        }
    }
 
    // -------------------------------------------------------
    // 4. Using field accessors
    // -------------------------------------------------------
    std::cout << "\n--- Field accessors ---" << std::endl;
    {
        user_entity user;
 
        // Set field values through accessors
        user.id = int64_t{1};
        user.username = std::string("john_doe");
        user.email = std::string("john@example.com");
        user.age = int32_t{30};
        user.is_active = true;
 
        // Read field values
        std::cout << "User: "
                  << "id=" << user.id.get()
                  << " username=" << user.username.get()
                  << " email=" << user.email.get()
                  << " age=" << user.age.get()
                  << " active=" << std::boolalpha << user.is_active.get()
                  << std::endl;
    }
 
    // -------------------------------------------------------
    // 5. Type trait checks
    // -------------------------------------------------------
    std::cout << "\n--- Type trait checks ---" << std::endl;
    {
        std::cout << "is_entity<user_entity>: "
                  << std::boolalpha << is_entity_v<user_entity> << std::endl;
        std::cout << "is_entity<post_entity>: "
                  << std::boolalpha << is_entity_v<post_entity> << std::endl;
        std::cout << "is_entity<int>: "
                  << std::boolalpha << is_entity_v<int> << std::endl;
 
        std::cout << "is_field_type<int32_t>: "
                  << std::boolalpha << is_field_type_v<int32_t> << std::endl;
        std::cout << "is_field_type<std::string>: "
                  << std::boolalpha << is_field_type_v<std::string> << std::endl;
        std::cout << "is_field_type<std::vector<int>>: "
                  << std::boolalpha << is_field_type_v<std::vector<int>> << std::endl;
    }
 
    std::cout << "\n=== orm_entity_demo example completed ===" << std::endl;
    return 0;
}

References database::orm::entity_metadata::create_indexes_sql(), database::orm::entity_metadata::create_table_sql(), database::orm::entity_base::get_metadata(), and database::orm::entity_metadata::table_name().

Here is the call graph for this function: