C++ ODB ORM 从入门到实战应用(ODB使用)

// person.hxx
#include <string>
#include <odb/core.hxx> // ODB核心头文件
// 标记为持久化类，对应数据库表"person"
#pragma db object table("person")
class Person
{
public:
    Person() {} // 必须提供默认构造函数
    Person(const std::string& name, int age, const std::string& email)
        : name_(name), age_(age), email_(email) {}
    // 访问器方法
    const std::string& name() const { return name_; }
    int age() const { return age_; }
    const std::string& email() const { return email_; }
private:
    // 主键（auto表示自增）
    #pragma db id auto
    unsigned long id_;
    // 普通字段（可指定列名、约束，如not_null）
    #pragma db column("name") not_null
    std::string name_;
    #pragma db column("age")
    int age_;
    #pragma db column("email") unique // 唯一约束
    std::string email_;
    // ODB需要访问私有成员，声明友元
    friend class odb::access;
};

# 针对MySQL生成代码，输出person-odb.hxx和person-odb.cxx
odb -d mysql --generate-query --generate-schema person.hxx

#include <odb/database.hxx>
#include <odb/mysql/database.hxx> // MySQL驱动
// 创建数据库连接（MySQL示例）
std::unique_ptr<odb::database> db(
    new odb::mysql::database(
        "root",      // 用户名
        "password",  // 密码
        "test_db",   // 数据库名
        "localhost", // 主机
        3306         // 端口
    )
);

#include "person-odb.hxx" // 生成的代码
Person p("Alice", 25, "alice@example.com");
odb::transaction t(db->begin()); // 开启事务
db->persist(p); // 插入对象到数据库
t.commit();     // 提交事务

odb::transaction t(db->begin());
std::shared_ptr<Person> p = db->load<Person>(1); // 根据主键1查询
std::cout << "Name: " << p->name() << ", Age: " << p->age() << std::endl;
t.commit();

#include <odb/query.hxx>
#include <odb/session.hxx>
odb::session s; // 查询需开启session
odb::transaction t(db->begin());
// 构建查询：age > 20 且 name LIKE 'A%'
odb::query<Person> q(
    odb::query<Person>::age > 20 &&
    odb::query<Person>::name.like("A%")
);
// 执行查询并遍历结果
for (auto& p : db->query<Person>(q))
    std::cout << p.name() << ": " << p.email() << std::endl;
t.commit();

odb::transaction t(db->begin());
std::shared_ptr<Person> p = db->load<Person>(1);
p->age_ = 26; // 修改对象（需将age_改为public或提供setter）
db->update(*p); // 更新数据库
t.commit();

odb::transaction t(db->begin());
db->erase<Person>(1); // 根据主键删除
t.commit();

// address.hxx
#pragma db object
class Address
{
    // ... 字段定义（主键id_，street_，city_等）
};
// person.hxx中添加关联
#pragma db object
class Person
{
    // ... 其他字段
    #pragma db one_to_one // 一对一关联
    odb::lazy_ptr<Address> address_; // 懒加载（访问时才查询）
};

// employee.hxx
#pragma db object
class Employee
{
    // ... 字段
    #pragma db many_to_one // 多对一（反向关联）
    odb::ptr<Department> dept_;
};
// department.hxx
#pragma db object
class Department
{
    // ... 字段
    #pragma db one_to_many(mapped_by = "dept_") // 一对多，指定反向关联字段
    std::vector<odb::ptr<Employee>> employees_;
};

#pragma db object abstract // 抽象父类
class User
{
    #pragma db id auto
    unsigned long id_;
    std::string username_;
};
#pragma db object
class AdminUser : public User
{
    std::string role_;
};
#pragma db object
class NormalUser : public User
{
    std::string avatar_;
};

odb::transaction t(db->begin());
try
{
    // 批量操作
    db->persist(p1);
    db->persist(p2);
    t.commit();
}
catch (const odb::exception& e)
{
    t.rollback(); // 异常时回滚
    std::cerr << "Transaction failed: " << e.what() << std::endl;
}

// role.hxx
#pragma db object
class Role
{
public:
    Role(const std::string& name) : name_(name) {}
private:
    friend class odb::access;
    Role() {}
    #pragma db id auto
    unsigned long id_;
    #pragma db not_null unique
    std::string name_; // 角色名：admin, user
};
// user.hxx
#pragma db object
class User
{
public:
    User(const std::string& name, int age) : name_(name), age_(age) {}
private:
    friend class odb::access;
    User() {}
    #pragma db id auto
    unsigned long id_;
    #pragma db not_null
    std::string name_;
    int age_;
    #pragma db many_to_many // 多对多关联角色
    std::vector<odb::ptr<Role>> roles_;
};

odb -d sqlite --generate-query --generate-schema role.hxx user.hxx
g++ -c user-odb.cxx role-odb.cxx main.cxx -I/path/to/odb/include -L/path/to/odb/lib -lodb -lodb-sqlite

#include <odb/sqlite/database.hxx>
#include "user-odb.hxx"
#include "role-odb.hxx"
int main()
{
    // SQLite数据库（文件test.db）
    std::unique_ptr<odb::database> db(new odb::sqlite::database("test.db"));
    // 1. 创建角色
    odb::transaction t1(db->begin());
    db->persist(Role("admin"));
    db->persist(Role("user"));
    t1.commit();
    // 2. 创建用户并关联角色
    odb::transaction t2(db->begin());
    auto admin_role = db->query_one<Role>(odb::query<Role>::name == "admin");
    User u("Bob", 30);
    u.roles_.push_back(admin_role);
    db->persist(u);
    t2.commit();
    // 3. 查询用户及其角色
    odb::session s;
    odb::transaction t3(db->begin());
    auto user = db->load<User>(1);
    std::cout << "User: " << user->name_ << ", Roles: ";
    for (auto& r : user->roles_)
        std::cout << r->name_ << " ";
    t3.commit();
    return 0;
}