简单的C++ ORM设计

其他 2018-05-09 21:40:54 阅读次数: 3

注：本文是由社区的BOT Man写的，由我代为发上来。

2016/11/15

“没有好的接口，用C++读写数据库和写图形界面一样痛苦”

阅读这篇文章前，你最好知道什么是
Object Relation Mapping (ORM)

为什么C++要ORM

As good object-oriented developers got tired of this repetitive work,
their typical tendency towards enlightened laziness started
to manifest itself in the creation of tools to help automate
the process.

When working with relational databases,
the culmination of such efforts were object/relational mapping tools.

  • 一般的C++数据库接口，都需要手动生成SQL语句；
  • 手动生成的查询字符串，常常会因为模型改动而失效 (这里超级容易出错)；
  • 查询语句/结果和C++原生数据之间的转换，每次都要手动解析；

市场上的C++ ORM

ODB

需要一个独立的 预编译器 生成模型和操作；

sqlpp11

使用 宏 生成模型和操作，使用起来也比较复杂；
不过个人比较喜欢这个设计；

Hiberlite ORM

  • 需要在定义模型时，插入 额外的代码 进行注入；
  • 没有条件查询和
    Transaction；

C++的ORM要做什么

  • 将对C++对象操作转化成SQL查询语句
    (LINQ to SQL)；
  • 提供C++ Style接口，更方便的使用；

一个可行的设计

一个实现了基本功能的C++ ORM —— ORM Lite

关于这个设计的代码和样例：

https://github.com/BOT-Man-JL/ORM-Lite

设计上大致分为6个方面：

  1. 封装SQL链接器
  2. 遍历对象内需要持久化的成员
  3. 序列化和反序列化
  4. 获取类名和各个字段的字符串
  5. 获取字段类型
  6. 将对C++对象的操作转化为SQL语句

1. 封装SQL链接器

为了让ORM支持各种数据库，
我们应该把对数据库的操作抽象为一个统一的 Execute：

1
2
3
4
5
6
class SQLConnector
{
public :
     SQLConnector ( const std :: string &connectionString ) ;
     void Execute ( . . . ) ;
} ;

  • 因为SQLite比较简单，目前只实现了SQLite的版本；
  • MySql版本应该会在
    这里 维护。。。

2. 遍历对象内需要持久化的成员

2.1 使用 Visitor Pattern + Variadic Template 遍历

一开始，我想到的是使用
Visitor Pattern
组合
Variadic Template
进行成员的遍历；

首先，在模型处加入 __Accept 操作；
通过 VISITOR 接受不同的 Visitor 来实现特定功能；
并用 __VA_ARGS__ 传入需要持久化的成员列表：

1
2
3
4
5
6
7
8
9
10
11
#define ORMAP(_MY_CLASS_, ...)                            \
template < typename VISITOR >                                \
void __Accept ( VISITOR &visitor )                            \
{                                                          \
     visitor . Visit ( __VA_ARGS__ ) ;                            \
}                                                          \
template < typename VISITOR >                                \
void __Accept ( VISITOR &visitor ) const                      \
{                                                          \
     visitor . Visit ( __VA_ARGS__ ) ;                            \
}

然后，针对不同功能，实现不同的 Visitor；
再通过统一的 Visit 接口，接受模型的变长数据成员参数；
例如 ReaderVisitor：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class ReaderVisitor
{
public :
     // Data to Exchange
     std :: vector < std :: string > serializedValues ;
 
     template < typename . . . Args >
     inline void Visit ( Args & . . . args )
     {
         _Visit ( args . . . ) ;
     }
 
protected :
     template < typename T , typename . . . Args >
     inline void _Visit ( T &property , Args & . . . args )
     {
         _Visit ( property ) ;
         _Visit ( args . . . ) ;
     }
    
     template < typename T >
     inline void _Visit ( T &property ) override
     {
         serializedValues . emplace_back ( std :: to_string ( property ) ) ;
     }
 
     template <>
     inline void _Visit < std :: string > ( std :: string &property ) override
     {
         serializedValues . emplace_back ( "'" + property + "'" ) ;
     }
} ;

  • Visit 将操作转发给带有变长模板的 _Visit；
  • 有变长模板的 _Visit 将各个操作转发给处理单个数据的 _Visit；
  • 处理单个数据的 _Visit 将模型的数据
    和 Visitor 一个 public 数据成员（ serializedValues）交换；

不过，这么设计有一定的缺点：

  • 我们需要预先定义所有的 Visitor，灵活性不够强；
  • 我们需要把和需要持久化的成员交换的数据保存到 Visitor 内部，
    增大了代码的耦合；

2.2 带有 泛型函数参数 的 Visitor

（使用了C++14的特性）

所以，我们可以让 Visit 接受一个泛型函数参数，用这个函数进行实际的操作；

在模型处加入的 __Accept 操作改为：

1
2
3
4
5
6
7
8
9
10
template < typename VISITOR , typename FN >                    \
void __Accept ( const VISITOR &visitor , FN fn )              \
{                                                          \
     visitor . Visit ( fn , __VA_ARGS__ ) ;                        \
}                                                          \
template < typename VISITOR , typename FN >                    \
void __Accept ( const VISITOR &visitor , FN fn ) const        \
{                                                          \
     visitor . Visit ( fn , __VA_ARGS__ ) ;                        \
}   

  • fn 为泛型函数参数；
  • 每次调用 __Accept 的时候，把 fn 传给 visitor 的 Visit 函数；

然后，我们可以定义一个统一的 Visitor，遍历传入的参数，并调用 fn ——
相当于将 Visitor 抽象为一个 for each 操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class FnVisitor
{
public :
     template < typename Fn , typename . . . Args >
     inline void Visit ( Fn fn , Args & . . . args ) const
     {
         _Visit ( fn , args . . . ) ;
     }
 
protected :
     template < typename Fn , typename T , typename . . . Args >
     inline void _Visit ( Fn fn , T &property , Args & . . . args ) const
     {
         _Visit ( fn , property ) ;
         _Visit ( fn , args . . . ) ;
     }
 
     template < typename Fn , typename T >
     inline void _Visit ( Fn fn , T &property ) const
     {
         fn ( property ) ;
     }
} ;

最后，实际的数据交换操作通过传入特定的 fn 实现：

1
2
3
4
5
queryHelper . __Accept ( FnVisitor ( ) ,
                       [ &argv , &index ] ( auto &val )
{
     DeserializeValue ( val , argv [ index ++ ] ) ;
} ) ;

  • 对比上边，这个方法实际上是在处理单个数据的 _Visit 将模型的数据
    传给回调函数 fn；
  • fn 使用
    Generic Lambda
    接受不同类型的数据成员，然后再转发给其他函数（ DeserializeValue）；
  • 通过capture和需要持久化的成员交换的数据；

2.3 另一种设计——用 tuple + Refrence 遍历

（使用了C++14的特性）

虽然最后版本没有使用这个设计，不过作为一个不错的思路，我还是记下来了；

首先，在模型处通过加入生成 tuple 的函数：

1
2
3
4
5
6
7
8
9
#define ORMAP(_MY_CLASS_, ...)                            \
inline decltype ( auto ) __ValTuple ( )                        \
{                                                          \
     return std :: forward_as_tuple ( __VA_ARGS__ ) ;            \
}                                                          \
inline decltype ( auto ) __ValTuple ( ) const                  \
{                                                          \
     return std :: forward_as_tuple ( __VA_ARGS__ ) ;            \
}

  • forward_as_tuple 将 __VA_ARGS__ 传入的参数转化为引用的 tuple；
  • decltype (auto) 自动推导返回值类型；

然后，定义一个 TupleVisitor：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Using a _SizeT to specify the Index :-), Cool
template < size_t > struct _SizeT { } ;
 
template < typename TupleType , typename ActionType >
inline void TupleVisitor ( TupleType &tuple , ActionType action )
{
     TupleVisitor_Impl ( tuple , action ,
                       _SizeT < std :: tuple_size < TupleType > :: value > ( ) ) ;
}
 
template < typename TupleType , typename ActionType >
inline void TupleVisitor_Impl ( TupleType &tuple , ActionType action , _SizeT < 0 > )
{ }
 
template < typename TupleType , typename ActionType , size _t N >
inline void TupleVisitor_Impl ( TupleType &tuple , ActionType action , _SizeT < N > )
{
     TupleVisitor_Impl ( tuple , action , _SizeT < N - 1 > ( ) ) ;
     action ( std :: get < N - 1 > ( tuple ) ) ;
}

  • 其中使用了 _SizeT 巧妙的进行 tuple 下标的判断；
  • 具体参考

    http://stackoverflow.com/questions/18155533/how-to-iterate-through-stdtuple

最后，类似上边，实际的数据交换操作通过 TupleVisitor 完成：

1
2
3
4
5
auto tuple = queryHelper . __ValTuple ( ) ;
TupleVisitor ( tuple , [ &argv , &index ] ( auto &val )
{
     DeserializeValue ( val , argv [ index ++ ] ) ;
} ) ;

2.4 问题

  • 使用 Variadic Template 和 tuple 遍历数据，
    其函数调用的确定，都是编译时就生成的，这会带来一定的代码空间开销；
  • 后两个方法可能在 实例化Generic Lambda 的时候，
    针对 不同类型的模型的 不同数据成员类型 实例化出不同的副本，
    代码大小更大；

3. 序列化和反序列化

通过 序列化，
将 C++ 数据类型转化为字符串，用于查询；
通过 反序列化，
将查询得到的字符串，转回 C++ 的数据类型；

3.1 重载函数 _Visit

针对每种支持的数据类型重载一个 _Visit 函数，
然后对其进行相应的序列化和反序列化；

以序列化为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void _Visit ( long &property ) override
{
     serializedValues . emplace_back ( std :: to_string ( property ) ) ;
}
 
void _Visit ( double &property ) override
{
     serializedValues . emplace_back ( std :: to_string ( property ) ) ;
}
 
void _Visit ( std :: string &property ) override
{
     serializedValues . emplace_back ( "'" + property + "'" ) ;
}

3.2 使用 std::iostream

然而，针对每种支持的数据类型重载，这种事情在标准库里已经有人做好了；
所以，我们可以改用了 std::iostream 进行序列化和反序列化；

以反序列化为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
template < typename T >
inline std :: ostream &SerializeValue ( std :: ostream &os ,
                                     const T &value )
{
     return os << value ;
}
 
template <>
inline std :: ostream &SerializeValue < std :: string > (
     std :: ostream &os , const std :: string &value )
{
     return os << "'" << value << "'" ;
}

4. 获取类名和各个字段的字符串

我们可以使用宏中的 # 获取传入参数的文字量；
然后将这个字符串作为 private 成员存入这个类中：

1
2
3
#define ORMAP(_MY_CLASS_, ...)                            \
constexpr static const char * __ClassName = #_MY_CLASS_;   \
constexpr static const char * __FieldNames = #__VA_ARGS__; \

其中
– #_MY_CLASS_ 为类名；
– #__VA_ARGS__ 为传入可变参数的字符串；
– __FieldNames 可以通过简单的字符串处理获得各个字段的字符串

5. 获取字段类型

在新建数据库的 Table 的时候，
我们不仅需要类名和各个字段的字符串，
还需要获得各个字段的数据类型；

5.1 使用 typeid 运行时判断

在 Visitor 遍历成员时，将每个成员的 typeid 保存起来：

1
2
3
4
5
template < typename T >
void _Visit ( T &property ) override
{
     typeIds . emplace_back ( typeid ( T ) ) ;
}

运行时根据 typeid 判断类型并匹配字符串：

1
2
3
4
5
6
7
8
if ( typeId == typeid ( int ) )
     typeFmt = "int" ;
else if ( typeId == typeid ( double ) )
     typeFmt = "decimal" ;
else if ( typeId == typeid ( std :: string ) )
     typeFmt = "varchar" ;
else
     return false ;

5.2 使用 &lt;type_traits&gt; 编译时判断

由于对象的类型在编译时已经可以确定，
所以我们可以直接使用 &lt;type_traits&gt; 进行编译时判断：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
constexpr const char * typeStr =
     ( std :: is_integral < T > :: value &&
     ! std :: is_same < std :: remove_cv_t < T > , char > :: value &&
     ! std :: is_same < std :: remove_cv_t < T > , wchar_t > :: value &&
     ! std :: is_same < std :: remove_cv_t < T > , char16_t > :: value &&
     ! std :: is_same < std :: remove_cv_t < T > , char32_t > :: value &&
     ! std :: is_same < std :: remove_cv_t < T > , unsigned char > :: value )
     ? "integer"
     : ( std :: is_floating_point < T > :: value )
     ? "real"
     : ( std :: is_same < std :: remove_cv_t < T > , std :: string > :: value )
     ? "text"
     : nullptr ;
 
static_assert (
     typeStr != nullptr ,
     "Only Support Integral, Floating Point and std::string :-)" ) ;

1
2
3
4
5
6
7
8
9
10
- ` constexpr ` * *编译时 * *完成推导，减少 * *运行时 * *开销；
- ` static_assert ` * *编译时 * *类型检查；
 
### 6. 将对C++对象的操作转化为SQL语句
 
对于一般的 * * Create * * * * Update * * * * Delete * * 操作比较容易转化为 SQL语句；
所以这里主要讨论如何实现 * *带有条件 * *的 * * Read * * 和 * * Delete * *；
 
除此之外，我们还应该提供
[ Fluent Interface ] ( https : //en.wikipedia.org/wiki/Fluent_interface)：

1
2
3
4
5
6
7
8
auto query = mapper . Query ( helper )
     . Where (
         Field ( helper . name ) == "July" &&
         ( Field ( helper . id ) <= 90 && Field ( helper . id ) >= 60 )
     )
     . OrderBy ( helper . id , true )
     . Limit ( 3 , 10 )
     . ToVector ( ) ;

我们可以使用一个 Query 对象，专门处理条件查询；
并在其带有条件的操作中，返回自己的引用，
从而实现Fluent Interface：

1
2
3
4
5
6
7
8
9
10
ORQuery Query ( C &queryHelper )
{
     return ORQuery ( queryHelper , this ) ;
}
 
ORQuery &Where ( const Expr &expr )
{
     // Parse expr
     return * this ;
}

6.2 自动将C++表达式转为SQL表达式

首先，引入一个 Expr 类，用于保存条件表达式；
将 Expr 对象传入 ORQuery.Where，以实现条件查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct Expr
{
     std :: vector < std :: pair < const void * , std :: string >> expr ;
 
     template < typename T >
     Expr ( const T &property ,
           const std :: string &relOp ,
           const T &value )
         : expr { std :: make_pair ( &property , relOp ) }
     {
         // Serialize value into expr.front ().second
     }
 
     inline Expr operator && ( const Expr &right )
     {
         // Return Composite Expression
     }
 
     // ...
}

  • expr 保存了表达式序列，包括该成员的指针和关系运算符 值的字符串；
  • 重载 &amp;&amp; || 实现表达式的复合条件；

不过这样的接口还不够友好；
因为如果我们要生成一个 Expr 则需要手动传入 const std::string &amp;relOp：

1
2
3
4
5
6
mapper . Query ( helper )
     . Where (
         Expr ( helper . name , "=" , std :: string ( "July" ) ) &&
         ( Expr ( helper . id , "<=" , 90 ) && Expr ( helper . id , ">=" , 60 ) )
     )
     // ...

所以，我们在这里引入一个 Field_Expr 实现自动构造表达式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
template < typename T >
struct Field_Expr
{
     const T & _property ;
 
     Field_Expr ( const T &property )
         : _property ( property )
     { }
 
     inline Expr operator == ( T value )
     { return Expr { _property , "=" , std :: move ( value ) } ; }
 
     // != > < >= <=
}
 
template < typename T >
Expr :: Field_Expr < T > Field ( T &property )
{
     return Expr :: Field_Expr < T > { property } ;
}

  • Field 函数用更短的语句，返回一个 Field_Expr 对象；
  • 重载 == != &gt; &lt; &gt;= &lt;= 生成带有对应关系的 Expr 对象；

6.3 自动判断C++对象的成员字段名

由于没有想到很好的办法，所以目前使用了指针进行运行时判断：

1
2
3
4
5
6
7
8
9
queryHelper . __Accept ( FnVisitor ( ) ,
                       [ &property , &isFound , &index ] ( auto &val )
{
     if ( ! isFound && property == &val )
         isFound = true ;
     else if ( ! isFound )
         index ++ ;
} ) ;
fieldName = FieldNames [ index ] ;

相当于使用 Visitor 遍历这个对象，找到对应成员的序号；

6.4 问题

之后的版本可能考虑：

  • 支持更多的SQL操作，并改用语法树实现；
  • 提供Transaction；（欢迎 Pull Request）

写在最后

这篇文章是我的第一篇技术类博客，写的比较浅，见谅；

你有一个苹果，我有一个苹果，我们彼此交换，每人还是一个苹果；
你有一种思想，我有一种思想，我们彼此交换，每人可拥有两种思想。

如果对以上内容及ORM Lite有什么问题，
欢迎 指点 讨论 

猜你喜欢

转载自blog.csdn.net/caoshiying/article/details/79840294
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022