Geekly Articles each Day
📜 ⬆️ ⬇️

ORM review for Qt

Introduction



Good afternoon, dear fellow programmers!

For a year now, very interesting events have taken place in the Qt world. Here you will find both the recent release of version 4.7, the concept of QML, and significant library integration into mobile platforms. Qt has the most correct trolls; I like what they do and where this library develops. I am even ready to argue that she is the best in her class, but those who write in Qt already know this.
')
There is something else that has changed over the year. For Qt, ORM libraries began to appear, one after another, like mushrooms. A holy place is never empty? There is a demand, here is your offer. Read what’s happening in the Qt ORM world in this article. I will try to give as much information as possible on the use and mechanisms used in the libraries reviewed; but none of them can be fully consecrated due to the fact that any ORM is a very complex set of programmer solutions.

(I will note right away that the article is to some extent an advertisement, because it appeared because of my own ORM; however, in fairness, I not only promote myself, but I also give a general assessment of what is on the topic now. Please treat with understanding: good intentions).


QxOrm, ver. 1.1.1



Author / owner : “QxOrm France”
Sites : Official , at SourceForge
License : GPLv3 + commercial
Dependencies : Qt (4.5+), boost (1.38+)
Development period : beginning of 2010, last modified - April 2010
Documentation : incomplete, in french
Examples : yes, the most basic

The main goal of the development is to provide persistence (via QtSql), serialization (via boost :: serialization) and reflection.

The library looks very strong and seems to be able to do a lot of things. Built on the principle of DAO ( Data Access Object ), when there is a class-displaying a row in a table, and a list of such rows is retrieved from some database using some methods. To make this possible, QxOrm uses very tricky mechanisms, including templates (a lot of templates), macros, simple and multiple inheritance. The code is very interesting for review if you are a fan of programmer tricks or, for example, you like Alexandrescu.

Judging by the examples, code and descriptions, the following features are implemented.

Pros:

Minuses:

Paradoxically, with all the drawbacks, QxOrm is almost the only full-fledged ORM solution compatible with Qt. And this is the only solution where there is caching, which is important for complex projects. You will see that this tiny review is still more than others, since other ORMs can hardly be compared to QxOrm. However, using the library in a large project, you may want some other opportunity, especially if you are working not with an abstract repository, but with a full-fledged DBMS - but it will not exist. You may want to fix a bug, but this is not so easy. You will have to reinvent a lot of bicycles and crutches. The project eventually will inevitably turn into a chimera. On the contrary, for a small project where only a few good functions are needed, the library can be useful, to the extent that you are not afraid to pull up and Boost.

Example of a mapper class (all code is taken from the documentation):

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 )


QX_REGISTER_CPP_MY_TEST_EXE ( drug ) // 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'
} }


Example of use:

// 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 Undergrounds
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)
boost :: any d_any = qx :: create ( "drug" ) ;

// Insert drugs container into 'qx :: cache'
qx :: cache :: set ( "drugs" , lst_drug ) ;



QDjango, ver. ???


Posted by : Jeremy Lainé, Bolloré telecom
Sites : official , mailing list
License : GPLv3, LGPLv3
Dependencies : Qt (4.5+)
In development since June 3, 2010
Documentation : complete, in English, doxygen-generated
Examples : there is, the most basic.

The main goal : to create a free ORM for Qt, the most similar to Django.

It’s too early to talk about the advantages and disadvantages of this development, the library is still unable to do anything. Apparently, it will be DAO / Active Record-ORM. Already it is possible to generate SELECT, to retrieve data in the container, to create tables through generation CREATE TABLE. The author immediately began to prescribe the generation WHERE; the operators AND and OR are supported. That is, you can create a multi-level filter, and the syntax for specifying filters is also good. The development actively uses the same methods as in QxOrm: patterns, inheritance ... Based on them, I guess, the author is going to create huge farms of good OOP code.
But that is all. We will believe that in a year and a half a powerful ORM system will grow from QDjango, but for now it is not possible to talk about its use in projects.

Example of use taken from the author.

// all users
QDjangoQuerySet < User > users ;

// find all users whose password is "foo" and whose username is not "bar"
QDjangoQuerySet < User > someUsers ;
someUsers = users. filter ( QDjangoWhere ( "password" , QDjangoWhere :: Equals , "foo" ) &&
QDjangoWhere ( "username" , QDjangoWhere :: NotEquals , "bar" ) ) ;

// find all users whose username is "foo" or "bar"
someUsers = users. filter ( QDjangoWhere ( "username" , QDjangoWhere :: Equals , "foo" ) ||
QDjangoWhere ( "username" , QDjangoWhere :: Equals , "bar" ) ) ;

// find all users whose username starts with "f":
someUsers = users. filter ( QDjangoWhere ( "username" , QDjangoWhere :: StartsWith , "f" ) ) ;

// limit number of results
someUsers = users. limit ( 0 , 100 ) ;

// get number of matching users
int numberOfUsers = someUsers. size ( ) ;

// retrieve the first matching user
User * firstUser = someUsers. at ( 0 ) ;

// free memory
delete firstUser ;

// retrieve list of users and passwords for matching users
QList < QList < QVariant >> propertyLists = someUsers. valuesList ( QStringList ( ) << "username" << "password" ) ;

// delete all users in the queryset
someUsers. remove ( ) ;

User class:

class User : public QDjangoModel
{
Q_OBJECT
Q_PROPERTY ( QString username READ username WRITE setUsername )
Q_PROPERTY ( QString password READ password WRITE setPassword )

Q_CLASSINFO ( "username" , "max_length = 255" )
Q_CLASSINFO ( "password" , "max_length = 128" )

public :
QString username ( ) const ;
void setUsername ( const QString & username ) ;

QString password ( ) const ;
void setPassword ( const QString & password ) ;

private :
QString m_username ;
QString m_password ;
} ;


QtPersistence, ver. 0.1.1


By Matt Rogers
Sites : SourceForge
License : LGPLv3
Dependencies : Qt (4.5+)
Development period : end of 2009 - beginning of 2010
Documentation : no
Examples : bad in unit tests

The main goal : to create an ORM for Qt, based on the Active Record approach, similar to some (?) ORM for Ruby.

Another library that can do almost nothing. What is worse: and does not develop; It seems that the author abandoned this project. Actually, all that it can do is to write data to the database using a mapper class.

The only examples of use are found in unit tests (based on a self-written test module).

class FakeBook : public QPersistantObject
{
Q_OBJECT
Q_PROPERTY ( QString author READ author set setAuthor WRITE )
Q_PROPERTY ( int yearPublished READ yearPublished WRITE setYearPublished )
public :
Q_INVOKABLE FakeBook ( QObject * parent = 0 ) : QPersistantObject ( parent ) { }
virtual ~ FakeBook ( ) { }

void setAuthor ( const QString & a ) { m_author = a ; }
QString author ( ) const { return m_author ; }

void setYearPublished ( int year ) { m_yearPublished = year ; }
int yearPublished ( ) const { Return m_yearPublished ; }

private :
QString m_author ;
int m_yearPublished ;
} ;

FakeBook * b = new FakeBook ;
b - > setAuthor ( "Matt Rogers" ) ;
b - > setYearPublished ( 2009 ) ;

bool objectSaved = b - > save ( ) ;
delete b ;
ASSERT_TRUE ( objectSaved ) ;

b = new FakeBook ;
b - > setAuthor ( "Not Matt Rogers" ) ;
b - > setYearPublished ( 1999 ) ;

objectSaved = b - > save ( ) ;
delete b ;
ASSERT_TRUE ( objectSaved ) ;


QsT SQL Tools (QST), ver. 0.4.2a release


The author : Alexander Granin (I :))
Sites : SourceForge , forum
License : GPLv3, LGPLv3
Dependencies : Qt (4.5+)
In development since September 2009
Documentation : full, doxygen-generated, only in Russian
Examples : is, in the code, in unit tests; I also created special projects-examples TradeDB for versions 0.3 and 0.4 - full-fledged database applications.

The main goal is to facilitate the programming of database applications under Qt.

Talking about your ORM is not easy. I got to Habr thanks to her, writing an article in the sandbox. The article did not cause interest ... But it was version 0.3 - and not even release version, but pre-alpha. Now I have gone far in the development of QST, and 0.5.1 pre-alpha is already available; but there is still a lot of things ahead that need to be done.

First of all: this is not the usual ORM. I began to write the library without knowing this term; I needed a query generation tool in order not to write them, and so that they were concentrated in one layer: it was easier to keep track of them. I did not even know about such approaches as Active Record. The result was what turned out: the original ORM, which is not quite ORM. You cannot configure class fields in it that would be displayed on table fields; it is impossible to write (read) the data directly to (from) the database using only the assignment. But you can have a lot of other things.

Opportunities, they are also advantages of the library.

Minuses? Of course there is, and quite a lot!


In general, the library is still in development, but already can do a lot of things. I use it in my work; and as a freelancer I write another project on it. In general, much less work falls on the programmer than with the one with QxOrm or with QDjango - this is evident from the source code of the examples. Described handlers, loaded view into them - get features that almost all are located in the main class (QstAbstractModelHandler). I introduce everything I need on the sly, but I can always be contacted - I will definitely help. Unlike. Therefore, I immodestly propose to support me in this difficult endeavor. Although even a wish for good luck; and better by any review. I will be grateful.

An example of a handler class and a DFD descriptor for a SELECT query.

Please note that information for setting up the views is also transferred to the QstField fields: field display, header and column width.
// personshandler.h
const int PERSONS = 1 ;
const int PERSONS_FULL_NAME = 2 ;

class PersonsHandler : public QstAbstractModelHandler
{
private :

QstBatch _selector ( const int & queryNumber ) const ;
QstBatch _executor ( const int & queryNumber ) const ;
} ;

// personshandler.cpp
QstBatch PersonsHandler :: _selector ( const int & queryNumber ) const
{
QstBatch batch ;

if ( queryNumber == PERSONS )
{
batch. addSource ( "vPersons" ) ;
batch << QstField ( RolePrimaryKey, "ID" )
<< QstField ( "Address_ID" )

<< QstField ( "LastName" , FieldVisible, "Last Name" , 100 )
<< QstField ( "FirstName" , FieldVisible, "Name" , 100 )
<< QstField ( "ParentName" , FieldVisible, "Middle Name " , 100 )
<< QstField ( "vcBirthDate" , FieldVisible, "Date \ n of birth" , 90 )
<< QstField ( "Phone" , FieldVisible, "Contact Phone \ n " , 120 )
<< QstField ( "[E-Mail]" , FieldVisible, "e-mail" , 120 )

<< QstField ( "ID" , value ( ID_VALUE ) , PurposeWhere )
;
}
else
if ( queryNumber == PERSONS_FULL_NAME )
{
batch. addSource ( "vPersons" ) ;
batch

<< QstField ( "FullName" , FieldVisible, "Full Name" , 300 )
<< QstField ( "LastName" , FieldVisible, "Last Name" , 100 )
<< QstField ( "FirstName" , FieldVisible, "Name" , 100 )
<< QstField ( "ParentName" , FieldVisible, "Middle Name " , 100 )
<< QstField ( "vcBirthDate" , FieldVisible, "Date \ n of birth" , 90 )
<< QstField ( "Phone" , FieldVisible, "Contact Phone \ n " , 120 )
<< QstField ( "[E-Mail]" , FieldVisible, "e-mail" , 120 )

<< QstField ( "ID" , value ( ID_VALUE ) , PurposeWhere )


<< QstField ( RolePrimaryKey, "ID" )
<< QstField ( "Address_ID" )
;
}
else
{
Q_ASSERT ( false ) ;
}

return batch ;
}

View setting:

// PersonsHandler _personsHandler;
// QstPlainQueryModel _personsModel; // - described in the PersonsForm class.

void PersonsForm :: loadPersons ( )
{
_personsHandler. reload ( PERSONS, & _personsModel ) ;
_personsHandler. setTableView ( ui - > tv_PersonsTableView ) ;
}

QVariant PersonsForm :: personID ( ) const
{
return _personsHandler. keyValueOfView ( ) ;
}

Using:

void PersonsForm :: loadPersonalDocumentInfo ( )
{
PersonalDocumentsHandler th ;
th. setValue ( "Person_ID" , personID ( ) ) ;
QVariantMap valMap = th. SelectToMap ( PERSONAL_DOCUMENTS,
QStringList ( )
<< "DocTypeName"
<< "SerialNumber"
<< "Number"
<< "vcIssueDate"
<< "GivenBy" ) ;
ui - > le_DocumentTypeLineEdit - > setText ( valMap [ "DocTypeName" ] . toString ( ) ) ;
ui - > le_SerialNumberLineEdit - > setText ( valMap [ "SerialNumber" ] . toString ( ) ) ;
ui - > le_NumberLineEdit - > setText ( valMap [ "Number" ] . toString ( ) ) ;
ui - > le_IssueDateDateEdit - > setDate ( valMap [ "vcIssueDate" ] . toDate ( ) ) ;
ui - > le_GivenByLineEdit - > setText ( valMap [ "GivenBy" ] . toString ( ) ) ;
}

Source: https://habr.com/ru/post/105191/

More articles:


All Articles