C++ ODB ORM 框架入门与实战示例

安装 ODB 运行时库

cd ..
bpkg create -d libodb-gcc-N cc \
    config.cxx=g++ \
    config.cc.coptions=-O3 \
    config.install.root=/usr/ \
    config.install.sudo=sudo
cd libodb-gcc-N
bpkg add https://pkg.cppget.org/1/beta
bpkg fetch
bpkg build libodb
bpkg build libodb-mysql

安装 Boost Profile 库

bpkg build libodb-boost

总体打包安装

bpkg install --all --recursive

常见操作

提示：接下以映射到 MySQL 数据库为示例演示。

核心头文件

在 C++ 中，要使用 ODB 将类声明为持久化类，需要包含 ODB 的核心头文件，并使用 #pragma db object 指令。

#include<cstddef>      // std::size_t
#include<boost/date_time/posix_time/posix_time.hpp>
#include<odb/nullable.hxx>
#include<odb/core.hxx>

类型映射

通过指令 #pragma 声明 C++ 类与数据库表之间的映射关系，必须放在它们所描述的 C++ 实体（类、数据成员、访问器）之前。格式：

#pragma db 指令 [参数...]

指令及参数：

• object：表示该类将被映射到数据库。
  • table()：默认生成的表名就是类名，使用该参数可以指定表名。
• id：表示该成员将被作为主键。
• auto：表示该成员有自增属性。
• unique：表示唯一键索引字段。
• index：为该字段创建普通索引。
• null：该字段允许为空。
• not_null：该字段不允许为空。
• default()：指定默认值。
• column()：指定该成员映射到数据库表后的列名。
• type()：指定该成员映射到数据库表中的字段类型。

示例 person.hxx 文件：

// 将上文的头文件包含
#pragma db object table("person")
class Person {
public:
private:
    friend class odb::access; // ODB 需要访问私有成员，所以需要做友元声明
    #pragma db id auto
    unsigned int _id;
    #pragma db column("user_age") default(18)
    unsigned short _age;
    #pragma db not_null
    std::string _name;
    #pragma db unique type("varchar(20)")
    std::string _phone;
};

代码编译：

odb -d mysql --generate-query --generate-schema --profile boost/date-time person.hxx

如下所示，自动生成了一个 SQL 脚本文件，通过指令 cat person.sql 查看该文件。

通过该文件构建 MySQL 数据库表：

mysql -u root -p 库名 < person.sql

登陆 MySQL 数据库查看表属性：

注意 1：

• 作用域：#pragma db 只影响紧随其后的类、数据成员或访问器。
• 顺序：多个属性可以写在同一行，也可以分开写。
• 访问控制：ODB 需要访问私有成员，通常使用 friend class odb::access。

注意 2：

• 数据库表的列名默认为成员变量名，但会去掉成员名的前缀下划线。

视图映射

ODB 视图是一个只读的、虚拟的投影，它基于一个或多个持久化类（数据库表），通过查询组合出你需要的数据结构。视图本身不对应数据库中的实际表，而是在查询时动态生成的结果集。

视图的核心特点：

• 只读性：视图只能用于查询，不能进行插入、更新、删除操作。
• 虚拟性：不占用实际数据库存储空间。
• 灵活性：可以自由组合多个表的字段，形成新的数据结构。
• 类型安全：在 C++ 编译期就确定了返回类型。

视图的两种定义方式：

方式一：基于对象关系的视图 这种视图使用 ODB 的查询语言来定义表之间的关联：

#pragma db view object(Student)\
object(Classes: Student::classes_id == Classes::id)
struct StudentClassView {
    #pragma db column(Student::name)
    std::string student_name;
    #pragma db column(Student::age)
    unsigned short student_age;
    #pragma db column(Classes::name)
    std::string class_name;
};

工作方式：

• object(Student)：指定主表。
• object(Classes: Student::classes_id == Classes::id)：指定关联表及连接条件。

相当于 SQL：

SELECT Student.name, Student.age, Classes.name FROM Student JOIN Classes ON Student.classes_id = Classes.id

方式二：基于原生 SQL 的视图 当需要复杂查询时，可以直接使用原生 SQL：

#pragma db view query("SELECT s.name, s.age, c.name "\
"FROM student s "\
"JOIN classes c ON s.classes_id = c.id "\
"WHERE s.age > ?")
struct AdultStudentView {
    std::string student_name;
    unsigned short student_age;
    std::string class_name;
};

特点：

• 使用 query("原生 SQL") 定义。
• ? 是参数占位符，可以在查询时传入具体值。
• 适合复杂的、对象关系无法表达的查询。

ODB 类与接口

• odb::database 类：实现数据库的增删改查操作。
  • 构造函数
  • 成员函数
  • 事务管理
  • 查询操作
  • 单对象操作
• odb::result 类：查询结果集。

测试示例

数据库操作流程：

1. 构造连接池对象。
2. 构造数据操作 database 对象。
3. 获取事务对象，开启事务。
4. 数据库操作。
5. 提交事务（若无添加，在销毁前会进行事务回滚）。

Student.hpp

#pragma once
#include<string>
#include<cstddef>// std::size_t
#include<boost/date_time/posix_time/posix_time.hpp>
#include<odb/nullable.hxx>
#include<odb/core.hxx>

class Student {
private:
    unsigned long _id;
    std::string _sn;
    std::string _name;
    unsigned short _age;
    unsigned long _classes_id;
};

class Classes {
private:
    unsigned long _id;
    std::string _name;
};

#pragma db view object(Student)\
object(Classes classes:Student._classes_id == Classes._id)\
query((?))
struct classes_student {
    #pragma db column(Student::_id)
    unsigned long _id;
    #pragma db column(Student::_sn)
    std::string _sn;
    #pragma db column(Student::_name)
    std::string _name;
    #pragma db column(Student::_age)
    unsigned short _age;
    #pragma db column(Classes::_name)
    std::string _classes_name;
};

#pragma db view query("select name from Student "+(?))
struct all_name {
    std::string _name;
};

test.cc

#include<gflags/gflags.h>
#include<odb/database.hxx>
#include<odb/mysql/database.hxx>
#include"student_classes.hxx"
#include"student_classes-odb.hxx"

DEFINE_string(host,"127.0.0.1","主机号");
DEFINE_uint32(port,0,"端口号");
DEFINE_string(db,"qsy_test","mysql 数据库名");
DEFINE_string(user,"root","mysql 用户名");
DEFINE_string(pswd,"I5sLBKpqjGjPZi","mysql 用户密码");
DEFINE_string(cset,"utf8","mysql 客户端字符集");
DEFINE_int32(max_pool,3,"最大的连接池数");

void insert_student(odb::mysql::database &db){
    try {
        odb::transaction trans(db.begin());
        Student s1(1,"张三",18,1);
        Student s2(2,"李四",19,1);
        Student s3(3,"王五",17,1);
        Student s4(4,"赵六",21,2);
        Student s5(5,"田七",20,2);
        Student s6(6,"孙八",16,2);
        Student s7(7,"罗九",26,2);
        db.persist(s1);
        db.persist(s2);
        db.persist(s3);
        db.persist(s4);
        db.persist(s5);
        db.persist(s6);
        db.persist(s7);
        trans.commit();
    }catch(std::exception &e){
        std::cout <<"数据插入失败："<< e.what()<< std::endl;
    }
}

void insert_classes(odb::mysql::database& db){
    try {
        odb::transaction trans(db.begin());
        Classes c1("1 班");
        Classes c2("2 班");
        db.persist(c1);
        db.persist(c2);
        trans.commit();
    }catch(const std::exception& e){
        std::cout<<"数据插入失败"<< e.what()<<'\n';
    }
}

void remove_student(odb::mysql::database& db){
    try {
        odb::transaction trans(db.begin());
        typedef odb::query<Student> query;
        db.erase_query<Student>(query::id ==4);
        trans.commit();
    }catch(const std::exception& e){
        std::cerr <<"删除失败："<< e.what()<<'\n';
    }
}

Student select_student(odb::mysql::database &db){
    Student ret;
    try {
        odb::transaction trans(db.begin());
        typedef odb::query<Student> query;
        typedef odb::result<Student> result;
        result r(db.query<Student>(query::name =="张三"));
        if(r.size()!=1){
            std::cout <<"查询失败"<< std::endl;
            return Student();
        }
        ret =*r.begin();
        trans.commit();
    }catch(const std::exception &e){
        std::cerr <<"查询失败"<< e.what()<<'\n';
    }
    return ret;
}

void select_student_classes(odb::mysql::database& db){
    try {
        odb::transaction trans(db.begin());
        typedef odb::query<struct classes_student> query;
        typedef odb::result<struct classes_student> result;
        result r(db.query<struct classes_student>(query::classes::id==1));
        for(auto it = r.begin();it!=r.end();it++){
            std::cout<<it->name<<" ";
            std::cout<<it->age<<" ";
            std::cout<<it->sn<<" ";
            std::cout<<it->classes_name<<" ";
            std::cout<<std::endl;
        }
        trans.commit();
    }catch(const std::exception& e){
        std::cout<<"查询失败："<<e.what()<<std::endl;
    }
}

void updata_student(odb::mysql::database &db, Student &stu){
    try {
        odb::transaction trans(db.begin());
        db.update(stu);
        trans.commit();
    }catch(const std::exception& e){
        std::cerr <<"更新失败："<< e.what()<<'\n';
    }
}

int main(int argc,char*argv[]){
    google::ParseCommandLineFlags(&argc,&argv, true);
    // 创建连接池构建配置对象
    std::unique_ptr<odb::mysql::connection_pool_factory>cpf(
        new odb::mysql::connection_pool_factory(FLAGS_max_pool,0));
    // 创建数据操作对象
    odb::mysql::database db(FLAGS_user, FLAGS_pswd, FLAGS_db, FLAGS_host, FLAGS_port,"", FLAGS_cset,0, std::move(cpf));
    // 插入
    // insert_student(db);
    // insert_classes(db);
    // 更新
    // Student stu = select_student(db);
    // stu.age(5);
    // updata_student(db,stu);
    // 删除
    // remove_student(db);
    // 查询
    select_student_classes(db);
    return 0;
}

Makefile

test : test.cc student_classes-odb.cxx
c++ -g $^ -o $@ -lodb-mysql -lodb -lodb-boost -lgflags