QxOrm 1.4.9
C++ Object Relational Mapping library
Loading...
Searching...
No Matches
QxOrm - C++ Object Relational Mapping library

QxOrm is a C++ library designed to provide Object Relational Mapping (ORM) feature to C++/Qt developers (like Hibernate in Java, or NHibernate in .Net).
QxOrm engine is based on a simple and non intrusive mapping function per class to provide :

  • Persistence (based on QtSql Qt module) ;
  • Serialization (JSON, XML and binary, based on Qt and boost serialization engines) ;
  • Reflection or Introspection (invoke dynamically class methods and access to properties) ;
  • HTTP web server : standalone multi-threaded HTTP 1.1 web server (support SSL/TLS, persistent connections, cookies, sessions, chunked responses, URL dispatcher/routing) ;
  • JSON API : interoperability with other technology than C++/Qt (REST web services, QML applications, scripting language).

QxOrm is developed by Lionel Marty, a software development engineer since 2003.
QxOrm library has been accepted into the Qt Ambassador Program.
QxOrm library is available on GitHub.

For more information about QxOrm library (quick sample, tutorial and forum), please visit : https://www.qxorm.com/.
A manual (user guide) to learn how to work with QxOrm library is available on QxOrm website.

Quick sample using QxOrm library

1- drug.h file : drug class definition with 3 properties : id, name and description

#ifndef _CLASS_DRUG_H_
#define _CLASS_DRUG_H_
class drug
{
public:
long id;
QString name;
QString description;
drug() : id(0) { ; }
virtual ~drug() { ; }
};
QX_REGISTER_HPP_MY_TEST_EXE(drug, qx::trait::no_base_class_defined, 1)
// This macro is necessary to register 'drug' class in QxOrm context
// param 1 : the current class to register => 'drug'
// param 2 : the base class, if no base class, use the qx trait => 'qx::trait::no_base_class_defined'
// param 3 : the class version used by serialization to provide 'ascendant compatibility'
#endif // _CLASS_DRUG_H_


2- drug.cpp file : setting function implementation - void qx::register_class()

#include "precompiled.h" // Precompiled-header with '#include <QxOrm.h>' and '#include "export.h"'
#include "drug.h" // Class definition 'drug'
#include <QxOrm_Impl.h> // Automatic memory leak detection and boost serialization export macro
QX_REGISTER_CPP_MY_TEST_EXE(drug) // This macro is necessary to register 'drug' class in QxOrm context
namespace qx {
template <> void register_class(QxClass<drug> & t)
{
t.id(& drug::id, "id"); // Register 'drug::id' <=> primary key in your database
t.data(& drug::name, "name", 1); // Register 'drug::name' property with key 'name' and version '1'
t.data(& drug::description, "desc"); // Register 'drug::description' property with key 'desc'
}}
QxOrm_Impl.h file should be included in all *.cpp files which depend on QxOrm library if you are usin...
void register_class(T &t)
qx::register_class<T>(T & t) : specialize this template to register a class of type T into QxOrm cont...
Definition QxClass.h:71
Root namespace for all QxOrm library features.


3- main.cpp file : basic functionalities of QxOrm library with drug class

#include "precompiled.h"
#include "drug.h"
#include <QxOrm_Impl.h>
int main(int argc, char * argv[])
{
QApplication app(argc, argv); // Qt application
// Create 3 new drugs
// It is possible to use 'boost' and 'Qt' smart pointer : 'boost::shared_ptr', 'QSharedPointer', etc...
typedef std::shared_ptr<drug> drug_ptr;
drug_ptr d1; d1.reset(new drug()); d1->name = "name1"; d1->description = "desc1";
drug_ptr d2; d2.reset(new drug()); d2->name = "name2"; d2->description = "desc2";
drug_ptr d3; d3.reset(new drug()); d3->name = "name3"; d3->description = "desc3";
// Insert drugs into container
// It is possible to use a lot of containers from 'std', 'boost', 'Qt' and 'qx::QxCollection<Key, Value>'
typedef std::vector<drug_ptr> type_lst_drug;
type_lst_drug lst_drug;
lst_drug.push_back(d1);
lst_drug.push_back(d2);
lst_drug.push_back(d3);
// Init parameters to communicate with a database
// Create table 'drug' into database to store drugs
QSqlError daoError = qx::dao::create_table<drug>();
// Insert drugs from container to database
// 'id' property of 'd1', 'd2' and 'd3' are auto-updated
daoError = qx::dao::insert(lst_drug);
// Modify and update the second drug into database
d2->name = "name2 modified";
d2->description = "desc2 modified";
daoError = qx::dao::update(d2);
// Delete the first drug from database
daoError = qx::dao::delete_by_id(d1);
// Count drugs into database
long lDrugCount = qx::dao::count<drug>();
// Fetch drug with id '3' into a new variable
drug_ptr d_tmp; d_tmp.reset(new drug());
d_tmp->id = 3;
daoError = qx::dao::fetch_by_id(d_tmp);
// Export drugs from container to a file under XML format (serialization)
qx::serialization::xml::to_file(lst_drug, "./export_drugs.xml");
// Import drugs from XML file into a new container
type_lst_drug lst_drug_tmp;
qx::serialization::xml::from_file(lst_drug_tmp, "./export_drugs.xml");
// Clone a drug
drug_ptr d_clone = qx::clone(* d1);
// Create a new drug by class name (factory)
qx::any d_any = qx::create("drug");
// Insert drugs container into 'qx::cache'
qx::cache::set("drugs", lst_drug);
// Remove all elements from 'qx::cache'
// Create a dummy memory leak
drug * pDummy = new drug();
return 0;
}
static QxSqlDatabase * getSingleton()
void setHostName(const QString &s, bool bJustForCurrentThread=false, QSqlDatabase *pJustForThisDatabase=NULL)
void setUserName(const QString &s, bool bJustForCurrentThread=false, QSqlDatabase *pJustForThisDatabase=NULL)
void setPassword(const QString &s, bool bJustForCurrentThread=false, QSqlDatabase *pJustForThisDatabase=NULL)
void setDatabaseName(const QString &s, bool bJustForCurrentThread=false, QSqlDatabase *pJustForThisDatabase=NULL)
void setDriverName(const QString &s, bool bJustForCurrentThread=false, QSqlDatabase *pJustForThisDatabase=NULL)
bool set(const QString &sKey, T &t, long lCost=1, const QDateTime &dt=QDateTime())
Insert object t into the cache with key sKey, associated cost lCost and insertion date-time dt....
Definition QxCache.h:170
void clear()
Delete all the objects in the cache.
Definition QxCache.h:148
QSqlError fetch_by_id(T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList())
Fetch an object t (retrieve all its properties) of type T (registered into QxOrm context) mapped to a...
Definition QxDao.h:636
QSqlError delete_by_id(T &t, QSqlDatabase *pDatabase=NULL, bool bUseExecBatch=false)
Delete a line (or list of lines) of a table (database) mapped to a C++ object of type T (registered i...
Definition QxDao.h:176
QSqlError insert(T &t, QSqlDatabase *pDatabase=NULL, bool bUseExecBatch=false)
Insert an element or a list of elements into database.
Definition QxDao.h:142
QSqlError update(T &t, QSqlDatabase *pDatabase=NULL, const QStringList &columns=QStringList(), bool bUseExecBatch=false)
Update an element or a list of elements into database.
Definition QxDao.h:683
QSqlError create_table(QSqlDatabase *pDatabase=NULL)
Create a table into database (with all columns) mapped to a C++ class T (registered into QxOrm contex...
Definition QxDao.h:264
long count(const qx::QxSqlQuery &query=qx::QxSqlQuery(), QSqlDatabase *pDatabase=NULL)
Return the number of lines in the table (database) mapped to the C++ class T (registered into QxOrm c...
Definition QxDao.h:98
qx::any create(const QString &sKey, bool bRawPointer=false)
Return a smart-pointer new instance of object (std::shared_ptr<T>) associated by key sKey using qx::a...
Definition QxFactoryX.h:110
std::shared_ptr< T > clone(const T &obj)
qx::clone(const T & obj) : return a boost smart-pointer (std::shared_ptr<T>) of a new instance of typ...
Definition QxClone.h:128


4- execute program and trace output debug

[QxOrm] qx::QxSqlDatabase : create new database connection in thread '3616' with key '{d315250c-b5c9-46e0-9402-f800368a6673}'
[QxOrm] sql query (78 ms) : CREATE TABLE drug (id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, name TEXT, desc TEXT)
[QxOrm] sql query (63 ms) : INSERT INTO drug (name, desc) VALUES (:name, :desc)
[QxOrm] sql query (62 ms) : UPDATE drug SET id = :id, name = :name, desc = :desc WHERE id = :id_bis
[QxOrm] sql query (63 ms) : DELETE FROM drug WHERE id = :id
[QxOrm] sql query (0 ms) : SELECT COUNT(*) FROM drug
[QxOrm] sql query (0 ms) : SELECT drug.id AS drug_id_0, drug.name AS drug_name_0, drug.desc AS drug_desc_0 FROM drug WHERE drug_id_0 = :id
[QxOrm] Leaked object at 0xf52ad8 (size 16, src\main.cpp:74)
[QxOrm] **** 1 memory leaks found ****
qx::QxSqlDatabase : define all parameters to connect to database and retrieve a valid connection by t...


5- export_drugs.xml file created by the program

<std.vector-boost.shared_ptr-drug-- class_id="0" tracking_level="0" version="0">
<count>3</count>
<item_version>1</item_version>
<item class_id="1" tracking_level="0" version="1">
<px class_id="2" tracking_level="1" version="1" object_id="_0">
<id>1</id>
<name class_id="3" tracking_level="0" version="0">name1</name>
<desc>desc1</desc>
</px>
</item>
<item>
<px class_id_reference="2" object_id="_1">
<id>2</id>
<name>name2 modified</name>
<desc>desc2 modified</desc>
</px>
</item>
<item>
<px class_id_reference="2" object_id="_2">
<id>3</id>
<name>name3</name>
<desc>desc3</desc>
</px>
</item>
</std.vector-boost.shared_ptr-drug-->