C++实现的ORM映射工具主要类介绍(一)

最新推荐文章于 2024-08-16 07:45:14 发布
最新推荐文章于 2024-08-16 07:45:14 发布
阅读量1k 收藏
点赞数
分类专栏： c++ 文章标签： c++ 工具 orm exception string null
 

/*基类:*/

template <typename T>
class OrmDBBase{
public:
 virtual int save(T t)=0;

 virtual int update(T t)=0;

 virtual int del(T t)=0;

 virtual list<T> selList(string selSql)=0;
   
};

 ===================================================================

/*对外接口*/

template <typename T>
class OrmDao{
private:
 Connection *pConnection;
public:
 OrmDao(Connection *pConnection)
 {
  this->pConnection=pConnection;
 }

 ~OrmDao()
 {
  OrmDBManager<T>::Destroy();
 }

 /*保存单个对象*/
 int save(T t)
 {
  try{
   return OrmDBManager<T>::getInstance(pConnection)->save(t);
  }catch(ORMException &e){
   throw;
  }
 }

 /*更新单个对象:主键作为条件*/
 int update(T t)
 {
  try{
   return OrmDBManager<T>::getInstance(pConnection)->update(t);
  }catch(ORMException &e){
   throw;
  }
 }

 /*删除单个对象*/
 int del(T t)
 {
  try{
   return OrmDBManager<T>::getInstance(pConnection)->del(t);
  }catch(ORMException &e){
   throw;
  }
 }

 /*查询语句*/
 list<T> selList(string selSql)
 {
  try{
   return OrmDBManager<T>::getInstance(pConnection)->selList(selSql);
  }catch(ORMException &e){
   throw;
  }
 }

};

==================================================================

/*管理类*/

template <typename T>
class OrmDBManager{
private:
 static OrmDBManager<T> *pOrmDBManager;
 static OrmDBBase<T> *pOrmDBBase;
 Connection *pConnection;
public:
 OrmDBManager(Connection *pConnection)
 {
  this->pConnection=pConnection;
  string driver=DBManager::getInstance()->getDBConfig()->getDataSouce()->getDriver();
  if (driver=="oracle"){
   pOrmDBBase=new OrmDBOracle<T>(pConnection);
  }
 }

 static void Destroy()
 {
  cout<<T::getTableName()<<"  OrmDBManager<T>::Destroy()"<<endl;
  if (pOrmDBManager!=NULL){
   delete pOrmDBManager;
   pOrmDBManager=NULL;
  }
  if (pOrmDBBase!=NULL){
   delete pOrmDBBase;
   pOrmDBBase=NULL;
  }
 }

 static OrmDBManager * getInstance(Connection *pConnection)
 {
  if (pOrmDBManager==NULL){
   pOrmDBManager=new OrmDBManager<T>(pConnection);
  }
  return pOrmDBManager;
 }

 int save(T t)
 {
  try{
   return pOrmDBBase->save(t);
  }catch(ORMException &e){
   throw;
  }
 }

 int update(T t)
 {
  try{
   return pOrmDBBase->update(t);
  }catch(ORMException &e){
   throw;
  }
 }

 int del(T t)
 {
  try{
   return pOrmDBBase->del(t);
  }catch(ORMException &e){
   throw;
  }
 }

 list<T> selList(string selSql)
 {
  try{
   return pOrmDBBase->selList(selSql);
  }catch(ORMException &e){
   throw;
  }
 }

};

template <typename T>
OrmDBManager<T> * OrmDBManager<T>::pOrmDBManager=NULL;

template <typename T>
OrmDBBase<T>* OrmDBManager<T>::pOrmDBBase=NULL;

=====================================================================

/*具体oracle实现类*/

#ifndef  _ORMDBORACLE_HPP_
#define  _ORMDBORACLE_HPP_

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include "ComFun.hpp"
#include "DBField.hpp"
#include "DBTable.hpp"
#include "DataSouce.hpp"
#include "DBMapping.hpp"
#include "DBConfig.hpp"
#include "DBManager.hpp"
#include "BeanProxy.hpp"
#include "LibraryMgr.hpp"
#include "OrmDBBase.hpp"
#include "Connection.hpp"
#include "DateTime.hpp"
#define  OTL_ORA9I
#include <otlv4.h>
#include "ORMException.hpp"

using namespace std;

template <typename T>
struct TypeTraits;

template<>
struct TypeTraits<int>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  int *pColContent=NULL;
  try{
   pColContent=new int();
   otlStream>>*pColContent;
   pBeanProxy->execVoidMethod(methodName,(void *)pColContent);
   delete pColContent;
   pColContent=NULL;
  }catch(otl_exception& p){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template<>
struct TypeTraits<long>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  long *pColContent=NULL;
  try{
   pColContent=new long();
   otlStream>>*pColContent;
   pBeanProxy->execVoidMethod(methodName,(void *)pColContent);
   delete pColContent;
   pColContent=NULL;
  }catch(otl_exception& p){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template<>
struct TypeTraits<float>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  float *pColContent=NULL;
  try{
   pColContent=new float();
   otlStream>>*pColContent;
   pBeanProxy->execVoidMethod(methodName,(void *)pColContent);
   delete pColContent;
   pColContent=NULL;
  }catch(otl_exception& p){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template<>
struct TypeTraits<double>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  double *pColContent=NULL;
  try{
   pColContent=new double();
   otlStream>>*pColContent;
   pBeanProxy->execVoidMethod(methodName,(void *)pColContent);
   delete pColContent;
   pColContent=NULL;
  }catch(otl_exception& p){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template<>
struct TypeTraits<char>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  char *pColContent=NULL;
  try{
   pColContent=new char[pDBField->getLength()+1];
   memset(pColContent,0,pDBField->getLength()+1);
   otlStream>>pColContent;
   string str=string(pColContent);
   pBeanProxy->execVoidMethod(methodName,(void *)&str);
   delete pColContent;
   pColContent=NULL;
  }catch(otl_exception& p){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pColContent!=NULL){
    delete pColContent;
    pColContent=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template<>
struct TypeTraits<CDateTime>{
 static void setAttriValue(otl_stream &otlStream,BeanProxy *pBeanProxy,string methodName,DBField * pDBField)
 {
  CDateTime *pCDateTime=NULL;
  try{
   otl_datetime oltDt;
   otlStream>>oltDt;
   pCDateTime=new CDateTime(oltDt.year,oltDt.month,oltDt.day,oltDt.hour,oltDt.minute,oltDt.second);
   pBeanProxy->execVoidMethod(methodName,(void *)pCDateTime);
   delete pCDateTime;
   pCDateTime=NULL;
  }catch(otl_exception& p){
   if (pCDateTime!=NULL){
    delete pCDateTime;
    pCDateTime=NULL;
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pCDateTime!=NULL){
    delete pCDateTime;
    pCDateTime=NULL;
   }
   throw ORMException(e.what());
  }
 }
};

template <typename T>
class OrmDBOracle : public OrmDBBase<T>{
private:
 Connection *pConnection;
 otl_connect *pOtlConn;
 bool showSql;
 string    tableName;
 DBTable   *pDBTable;
 BeanProxy *pBeanProxy;

 void printSql(string sql)
 {
  if (showSql==true){
   cout<<sql<<endl;
  }
 }

 /*获得列表*/
 void getColumnList(map<string,DBField *> fieldsMap,vector<string> &colVector,vector<string> &colVarVector,int seq)
 {
  colVector.clear();
  colVarVector.clear();
  map<string,DBField *>::iterator iterField=fieldsMap.begin();
  while(iterField!=fieldsMap.end()){
   string colName=iterField->first;
   DBField *pDBField=(DBField *)iterField->second;
   string sqlType=pDBField->getSqlType();
   colVector.push_back(colName);
   char tmpVal[10];
   memset(tmpVal,0,10);
   sprintf(tmpVal,"%d",seq);
   ComFun::trim(tmpVal);
   string paraSeq=":para"+string(tmpVal);
   if (sqlType=="int"||sqlType=="integer"){
    colVarVector.push_back(paraSeq+"<int>");
   }else if(sqlType=="date"){
    colVarVector.push_back(paraSeq+"<timestamp>");
   }else if (sqlType=="long"){
    colVarVector.push_back(paraSeq+"<long>");
   }else if (sqlType=="float"){
    colVarVector.push_back(paraSeq+"<float>");
   }else if (sqlType=="double"){
    colVarVector.push_back(paraSeq+"<double>");
   }else if (sqlType=="char"||sqlType=="varchar2"){
    memset(tmpVal,0,10);
    sprintf(tmpVal,"%d",pDBField->getLength()+1);
    ComFun::trim(tmpVal);
    string var="["+string(tmpVal)+"]";
    colVarVector.push_back(paraSeq+"<char"+var+">");
   }
   seq++;
   iterField++;
  }
 }

 /*给变量赋值*/
 void setVarValue(BeanProxy *pBeanProxy,otl_stream &otlStream,map<string,DBField *> fieldsMap)
 {
  try{
   map<string,DBField *>::iterator iterField=fieldsMap.begin();
   while(iterField!=fieldsMap.end()){
    string colName=ComFun::toLower(iterField->first);
    DBField *pDBField=(DBField *)iterField->second;
    string sqlType=pDBField->getSqlType();
    vector<string> subColVector;
    subColVector.clear();
    /*列名:拆分为*/
    subColVector=ComFun::split(colName,"_");
    string methodName="get";
    for(int i=0;i<subColVector.size();i++){
     string subCol=subColVector[i];
     methodName=methodName+ComFun::toUpper(subCol.substr(0,1))+subCol.substr(1,subCol.size()-1);;
    }
    /*获得属性值*/
    void *attrValue=pBeanProxy->execGetMethod(methodName);
    //cout<<"methodName:"<<methodName<<endl;
    if (sqlType=="int"||sqlType=="integer"){
     otlStream<<*(int *)attrValue;
    }else if (sqlType=="long"){
     otlStream<<*(long *)attrValue;
    }else if (sqlType=="float"){
     otlStream<<*(float *)attrValue;
    }else if (sqlType=="double"){
     otlStream<<*(double *)attrValue;
    }else if (sqlType=="char"||sqlType=="varchar2"){
     otlStream<<(*(string*)attrValue).c_str();
    }else if (sqlType=="date"){
     otl_datetime otlDt;
     CDateTime dt;
     string format=dt.getFormat();
     dt=*(CDateTime *)attrValue;
     otlDt.year=dt.getYear();
     otlDt.month=dt.getMonth();
     otlDt.day=dt.getDay();
     if (format.find("%H")!=-1&&format.find("%M")!=-1&&format.find("%S")!=-1){
      otlDt.hour=dt.getHour();
      otlDt.minute=dt.getMinute();
      otlDt.second=dt.getSecond();
     }
     if (dt.getTime()>0){
      otlStream<<otlDt;
     }else{
      otlStream<<otl_null();
     }
    }
    iterField++;
   }
  }catch(otl_exception& p){
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   throw ORMException(e.what());
  }
 }

public:
 OrmDBOracle(Connection *pConnection)
 {
  this->pConnection=pConnection;
  pOtlConn=(otl_connect *)pConnection->getConnection();
  showSql=DBManager::getInstance()->getDBConfig()->getDataSouce()->getShowSql();
  tableName=ComFun::toUpper(T::getTableName());
  pDBTable=DBManager::getInstance()->getDBConfig()->getDBMapping()->getTable(tableName);
  pBeanProxy=(BeanProxy *)LibraryMgr::getInstance()->getFunction(pDBTable->getClassName());
 }

 /*保存单个对象*/
 int save(T t)
 {
  try{
   string insertSql="insert into "+tableName+" ";
   map<string,DBField *> fieldsMap=pDBTable->getColumnsMap();
   if (fieldsMap.size()==0){
    return RET_FAIL;
   }
   insertSql=insertSql+"(";
   string valueSql=" values(";
   vector<string> colVector;
   vector<string> colVarVector;
   getColumnList(fieldsMap,colVector,colVarVector,1);
   for(int i=0;i<colVector.size();i++){
    if (i==colVector.size()-1){
     insertSql=insertSql+colVector[i];
     valueSql=valueSql+colVarVector[i];
    }else{
     insertSql=insertSql+colVector[i]+",";
     valueSql=valueSql+colVarVector[i]+",";
    }
   }
   insertSql=insertSql+") "+valueSql+")";
   printSql(insertSql);
   otl_stream otlInsert(1,insertSql.c_str(),*pOtlConn);
   otlInsert.set_commit(0);
   pBeanProxy->setBean(&t);
   setVarValue(pBeanProxy,otlInsert,fieldsMap);
   pBeanProxy->delPtr();
   return RET_SUCESS;
  }catch(otl_exception& p){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException(e.what());
  }
 }

 /*更新单个对象:主键作为条件*/
 int update(T t)
 {
  try{
   string updateSql="update "+tableName+" set ";
   map<string,DBField *> fieldsMap=pDBTable->getColumnsMap();
   map<string,DBField *> pkFieldsMap=pDBTable->getPKColumnsMap();
   map<string,DBField *> otherFieldsMap;
   otherFieldsMap.clear();
   if (fieldsMap.size()==0){
    return RET_FAIL;
   }

   if (pkFieldsMap.size()==0){
    return RET_FAIL;
   }
   map<string,DBField *>::iterator iterField=fieldsMap.begin();
   while(iterField!=fieldsMap.end()){
    string colName=iterField->first;
    DBField *pDBField=(DBField *)iterField->second;
    if (pkFieldsMap.count(colName)==0){
     otherFieldsMap[colName]=pDBField;
    }
    iterField++;
   }
   if (otherFieldsMap.size()==0){
    return RET_FAIL;
   }
   vector<string> colOtherVector;
   vector<string> colOtherVarVector;
   getColumnList(otherFieldsMap,colOtherVector,colOtherVarVector,1);
   for(int i=0;i<colOtherVector.size();i++){
    if (i==colOtherVector.size()-1){
     updateSql=updateSql+colOtherVector[i]+"="+colOtherVarVector[i];
    }else{
     updateSql=updateSql+colOtherVector[i]+"="+colOtherVarVector[i]+",";
    }
   }
   string whereSql="";
   vector<string> colPKVector;
   vector<string> colPKVarVector;
   getColumnList(pkFieldsMap,colPKVector,colPKVarVector,otherFieldsMap.size()+1);
   for(int i=0;i<colPKVector.size();i++){
    if (i==colPKVector.size()-1){
     whereSql=whereSql+colPKVector[i]+"="+colPKVarVector[i];
    }else{
     whereSql=whereSql+colPKVector[i]+"="+colPKVarVector[i]+" and ";
    }
   }
   updateSql=updateSql+" where "+whereSql;
   printSql(updateSql);
   otl_stream otlUpdate(1,updateSql.c_str(),*pOtlConn);
   otlUpdate.set_commit(0);
   pBeanProxy->setBean(&t);
   setVarValue(pBeanProxy,otlUpdate,otherFieldsMap);
   setVarValue(pBeanProxy,otlUpdate,pkFieldsMap);
   pBeanProxy->delPtr();
   return RET_SUCESS;
  }catch(otl_exception& p){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException(e.what());
  }

 }

 /*删除单个对象*/
 int del(T t)
 {
  try{
   string delSql="delete from "+tableName+" where ";
   map<string,DBField *> pkFieldsMap=pDBTable->getPKColumnsMap();
   if (pkFieldsMap.size()==0){
    return RET_FAIL;
   }
   string whereSql="";
   vector<string> colVector;
   vector<string> colVarVector;
   getColumnList(pkFieldsMap,colVector,colVarVector,1);
   for(int i=0;i<colVector.size();i++){
    if (i==colVector.size()-1){
     whereSql=whereSql+colVector[i]+"="+colVarVector[i];
    }else{
     whereSql=whereSql+colVector[i]+"="+colVarVector[i]+" and ";
    }
   }
   delSql=delSql+whereSql;
   printSql(delSql);
   otl_stream otlDel(1,delSql.c_str(),*pOtlConn);
   otlDel.set_commit(0);
   pBeanProxy->setBean(&t);
   setVarValue(pBeanProxy,otlDel,pkFieldsMap);
   pBeanProxy->delPtr();
   return RET_SUCESS;
  }catch(otl_exception& p){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   if (pBeanProxy!=NULL){
    pBeanProxy->delPtr();
   }
   throw ORMException(e.what());
  }
 }

 /*查询语句*/
 list<T> selList(string selSql)
 {
  otl_stream otlSelect;
  try{
   list<T> tmpList;
   tmpList.clear();
   int descLen = 0;
   otlSelect.set_commit(0);
   map<string,DBField *> fieldsMap=pDBTable->getColumnsMap();
   otlSelect.open(50,selSql.c_str(),*pOtlConn);
   otl_column_desc *desc=otlSelect.describe_select(descLen);
   while(!otlSelect.eof()){
    T t;
    //memset(&t,0,sizeof(T));
    pBeanProxy->setBean((void *)&t);
    for(int i=0;i<descLen;i++){
     string colName=string(ComFun::trim(desc[i].name));
     map<string,DBField *>::iterator iter = fieldsMap.find(colName);
     if (iter!=fieldsMap.end()){
      DBField * pDBField=(DBField *)iter->second;
      string sqlType=pDBField->getSqlType();
      colName=ComFun::toLower(colName);
      vector<string> subColVector;
      subColVector.clear();
      subColVector=ComFun::split(colName,"_");
      string methodName="set";
      for(int i=0;i<subColVector.size();i++){
       string subCol=subColVector[i];
       methodName=methodName+ComFun::toUpper(subCol.substr(0,1))+subCol.substr(1,subCol.size()-1);;
      }
      if (sqlType=="int"||sqlType=="integer"){
       TypeTraits<int>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }else if (sqlType=="long"){
       TypeTraits<long>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }else if (sqlType=="float"){
       TypeTraits<float>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }else if (sqlType=="double"){
       TypeTraits<double>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }else if (sqlType=="char"||sqlType=="varchar2"){
       TypeTraits<char>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }else if (sqlType=="date"){
       TypeTraits<CDateTime>::setAttriValue(otlSelect,pBeanProxy,methodName,pDBField);
      }
     }
    }
    tmpList.push_back(t);
   }
   otlSelect.close();
   return tmpList;
  }catch(otl_exception& p){
   otlSelect.close();
   throw ORMException((const char *)p.msg);
  }catch(exception &e){
   otlSelect.close();
   throw ORMException(e.what());
  }
 }

};

#endif

moyumoyu
关注
专栏目录
C++实现的ORM映射工具
bingfox的专栏
04-15 3742
  1      OrmDao简介1.1.    对象关系-映射简介对像和关系数据是业务实体的两种表现形式,业务实体在内存中表现为对象，数据库中表现为关系数据, 内存中的对象之间存在关联和继承关系, 而在数据库中，关系数据无法直接表达多对多关联和继承关系, 因此,对象-关系映射(ORM)系统一般以中间件的形式存在, 主要实现程序对象到关系数据库数据的映射.在开发关系数据库的系统时,
如何设计一个简单的C++ ORM
qq_21302633的博客
12-01 1053
如何设计一个简单的C++ ORM 2016/11/15 “没有好的接口，用C++读写数据库和写图形界面一样痛苦” 阅读这篇文章前，你最好知道什么是 Object Relation Mapping (ORM)阅读这篇文章后，欢迎阅读下一篇 如何设计一个更好的C++ ORM ��为什么C++要ORM As good object-oriented developers got ti
推荐一款现代C++ ORM框架: ORM Lite
最新发布
gitblog_00353的博客
08-16 975
???? 推荐一款现代C++ ORM框架: ORM Lite ORM-LiteHeader-Only, Strong-Typed, Compile-time Object Relation Mapping (ORM) in Modern C++ :-)项目地址:https://gitcode.com/gh_mirrors/or/ORM-Lite 在寻找高效且易于使用的数据库抽象层时, ORM Lite...
C++ ORM
fg100emil的专栏
03-21 4414
公司要开发一个server端C++程序，原来的做法都是raw sql。我希望能不能将ORM用进去，搜了一下c++的ORM库，很有限，而且可能支持的并不好（由于c++的反射问题？）。先记在这里，希望能派上用场。目前还处在需求分析建模阶段。 C++ ORM:Database Template LibrarySOCIoriginal discussion site 
C++实现的ORM映射工具类介绍(二)
bingfox的专栏
04-15 1305
 ================================================================/*数据库连接对象*/class Connection{private:   string driver;   void   *pConn;public:   Connection();   ~Connection();   void * getConnecti
YB.ORM:用于C ++的对象关系映射（ORM）的工具-开源
04-13
YB.ORM是用于C ++的对象关系映射（ORM）的工具。 受到Hibernate或SQLAlchemy之类的启发。 应该与数据库无关。 包括用于域对象代码生成的工具。 表的元数据描述是一个XML文件。
C++高级编程（99）面向资源的设计思想（ORM）
m0_51768024的博客
05-01 231
ORM是一种将对象的状态映射到数据库的技术，它允许开发者通过操作对象来实现对数据库的操作。这样，开发者可以专注于业务逻辑，而不是数据库访问代码。通过本篇博客的学习，我们应该能够理解ORM的概念、优势以及在C++中的应用。虽然C++不是传统的ORM应用场景，但是通过设计合理的ORM框架，我们仍然可以在C++中实现面向资源的设计理念。在实践中，我们需要不断地学习和实践，以深入掌握这些复杂的理论和技术。随着技术的发展，我们期待有更多先进的工具和方法论来帮助我们更好地理解和使用ORM。
sqlite_orm：:red_heart_selector:SQLite ORM light header仅用于现代C ++库
01-30
`sqlite_orm` 是一个轻量级的C++库，专为现代C++设计，用于实现SQLite数据库的对象关系映射（ORM）。ORM是一种编程技术，它允许开发者使用面向对象的编程语言来操作数据库，而无需直接编写SQL语句。通过ORM，C++代码...
QxOrm：QxOrm库-C ++ Qt ORM（对象关系映射）和ODM（对象文档映射器）库-官方存储库
01-30
QxOrm是一个强大的开源库，专门用于C++编程语言，并且与Qt框架紧密集成，提供了ORM（对象关系映射）和ODM（对象文档映射器）的功能。这个库允许开发者将数据库操作与业务逻辑解耦，使得在C++应用程序中处理数据库...
YB.ORM_0.4.0(C++的ORM框架)
10-27
YB.ORM 库的目标是简化编写C++代码中处理SQL数据库。我们的目标是提供一个方便的接口，类似 SQLAlchemy或Hibernate（JAVA）。 库本身是跨平台的，支持各种SQL方言：如 sqlite、MySQL、Postgres、Oracle 等。
dquest:DQuest - Qt 框架的 C++ ORM（对象关系映射）
06-06
DQuest 是 Qt 框架的 C++ ORM（对象关系映射）。 它旨在为具有数据库访问权限的应用程序提供快速开发环境。 数据库模型声明非常简单，就像其他 C++/Qt 类（示例）一样。 它专为移动环境而设计，但也适用于不需要最大化数据库性能的桌面和嵌入式应用程序。 越来越多的应用程序使用 Sqlite 来存储数据。 但是，在 SQL 中编写数据模型很复杂。 通常需要写两套接口：一套用于C/C++，一套用于Sql。 工作量重复，调试麻烦。 使用 DQuest，您可以直接使用 C++ 声明数据库模型。 可以通过 C++ 接口进行读/写访问。 您无需编写任何 SQL 即可获得在应用程序中使用 Sqlite 的好处。 要声明您的数据库模型，您需要： 创建一个继承 DQModel 的类 在类声明中添加了 DQ_MODEL 宏 使用 DQField 模板类型设计数据库字段 使用 DQ_DEC
C++ ORM Matador
nightwizard2030的博客
02-20 1785
对于关系型数据库，sql无疑是让人头疼的地方，个人对写这种重复CRUD的代码简直觉得是恶心透底，要是表再一多，瞬间爆炸。 对于c++，我以往本身还是很排斥ORM的，毕竟那是java和c#喜欢用的东西，感觉没有什么比较顺眼的开源框架，直到这次在巨大压力下尝试matador这个框架，其本身简洁的语法以及极低依赖深深吸引了我，没想到在c++里orm也可以实现得如此优雅。支持采用db first 和 c...
C++ 对象关系映射（ORM）介绍
qimo601的专栏
02-28 983
用过Java的都知道SSH框架，特别对于数据库开发，Java领域有无数的ORM框架，供数据持久层调用，如Hibernate，iBatis(现在改名叫MyBatis)，TopLink，JDO，JPA……非常方便实用。 用过C#的同学们也都知道通过CodeSmith软件，生成微软的PetShop分层模式，达到数据持久层的代码，也非常方便。 那么我们用C++的怎么办，我们也是面向对象编程，在工作...
C++实现的ORM映射工具类介绍(三)
bingfox的专栏
04-15 1315
================================================================DBMapping类:class DBMapping{private: map *pTableMap; void delTabPtrFromMap(map *pMap);public: DBMapping(); ~DBMapping(); void addTabl
C++ orm介绍
一叶知秋的博客
06-25 2418
https://www.cnblogs.com/lvdongjie/p/6163368.html
C++的ORM 开源框架
weixin_30561177的博客
09-21 520
C++的ORM 开源框架 介绍一个C++的ORM工具ODB SOCI、LiteSQL、POCO数据库访问类库对比 转载于:https://www.cnblogs.com/jingzhishen/p/5892488.html
非侵入C++ ORM
lk_HIT的博客
08-10 1308
最近工作中需要将一些信息保存到数据库，由于使用的是C++，没有反射机制，所以对应的ORM库非常少，手写sql又非常麻烦，这个时候非常羡慕java,C#等语言可以在编译的时候就将字段信息等编译到可执行文件中，因此可以非常轻松的实现反射，也有非常多好用成熟的ORM库。 本文主要是利用C++的宏和模板来实现非侵入式简单的C++ORM的功能（主要是针对sqlite数据库） （1）要利用C++实现反射，最主要的是可以获取C++结构体各个字段的字段名，字段类型。我在网上找到一段如下的宏可以很好的解决这个问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值