| QxOrm 1.1.8 C++ Object Relational Mapping library

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Directories

- File List
- File Members

QxSqlRelation_ManyToOne.h
Go to the documentation of this file.

    00001 /****************************************************************************
    00002 **
    00003 ** http://www.qxorm.com/
    00004 ** http://sourceforge.net/projects/qxorm/
    00005 ** Original file by Lionel Marty
    00006 **
    00007 ** This file is part of the QxOrm library
    00008 **
    00009 ** This software is provided 'as-is', without any express or implied
    00010 ** warranty. In no event will the authors be held liable for any
    00011 ** damages arising from the use of this software.
    00012 **
    00013 ** GNU Lesser General Public License Usage
    00014 ** This file must be used under the terms of the GNU Lesser
    00015 ** General Public License version 2.1 as published by the Free Software
    00016 ** Foundation and appearing in the file 'license.lgpl.txt' included in the
    00017 ** packaging of this file.  Please review the following information to
    00018 ** ensure the GNU Lesser General Public License version 2.1 requirements
    00019 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    00020 **
    00021 ** If you have questions regarding the use of this file, please contact :
    00022 ** contact@qxorm.com
    00023 **
    00024 ****************************************************************************/
    00025
    00026 #ifndef _QX_SQL_RELATION_MANY_TO_ONE_H_
    00027 #define _QX_SQL_RELATION_MANY_TO_ONE_H_
    00028
    00029 #ifdef _MSC_VER
    00030 #pragma once
    00031 #endif
    00032
    00040 #include <QxDao/QxSqlRelation.h>
    00041
    00042 namespace qx {
    00043
    00048 template <class DataType, class Owner>
    00049 class QxSqlRelation_ManyToOne : public QxSqlRelation<DataType, Owner>
    00050 {
    00051
    00052 private:
    00053
    00054    typedef typename QxSqlRelation<DataType, Owner>::type_owner type_owner;
    00055    typedef typename QxSqlRelation<DataType, Owner>::type_data type_data;
    00056
    00057 public:
    00058
    00059    QxSqlRelation_ManyToOne(IxDataMember * p) : QxSqlRelation<DataType, Owner>(p) { ; }
    00060    virtual ~QxSqlRelation_ManyToOne() { ; }
    00061
    00062    virtual bool getCartesianProduct() const                                   { return false; }
    00063    virtual void lazyFrom(QxSqlRelationParams & params) const                  { Q_UNUSED(params); }
    00064    virtual void eagerFrom(QxSqlRelationParams & params) const                 { Q_UNUSED(params); }
    00065    virtual void lazyJoin(QxSqlRelationParams & params) const                  { Q_UNUSED(params); }
    00066    virtual void lazyWhere(QxSqlRelationParams & params) const                 { Q_UNUSED(params); }
    00067    virtual void eagerWhere(QxSqlRelationParams & params) const                { Q_UNUSED(params); }
    00068    virtual void lazyWhereSoftDelete(QxSqlRelationParams & params) const       { Q_UNUSED(params); }
    00069    virtual void lazyFetch_ResolveInput(QxSqlRelationParams & params) const    { Q_UNUSED(params); }
    00070    virtual void eagerFetch_ResolveInput(QxSqlRelationParams & params) const   { Q_UNUSED(params); }
    00071    virtual QSqlError onBeforeSave(QxSqlRelationParams & params) const         { Q_UNUSED(params); return QSqlError(); }
    00072    virtual QSqlError createExtraTable(QxSqlRelationParams & params) const     { Q_UNUSED(params); return QSqlError(); }
    00073
    00074    virtual QSqlError onAfterSave(QxSqlRelationParams & params) const
    00075    { return qx::dao::save(this->getData(params), (& params.database())); }
    00076
    00077    virtual void lazyUpdate_ResolveInput(QxSqlRelationParams & params) const
    00078    { this->lazyInsert_ResolveInput(params); }
    00079
    00080    virtual QVariant getIdFromQuery(bool bEager, QxSqlRelationParams & params) const
    00081    {
    00082       Q_UNUSED(bEager); QString sId; IxDataMember * pId = this->getDataId(); if (! pId) { return QVariant(); }
    00083       for (int i = 0; i < pId->getNameCount(); i++) { sId += params.query().value(params.offset() + i).toString() + "|"; }
    00084       return QVariant(sId);
    00085    }
    00086
    00087    virtual void updateOffset(bool bEager, QxSqlRelationParams & params) const
    00088    {
    00089       long lOffsetDataMember = (this->getDataMember() ? this->getDataMember()->getNameCount() : 0);
    00090       long lOffsetDataId = (bEager ? (this->getDataId() ? this->getDataId()->getNameCount() : 0) : 0);
    00091       long lOffsetDataCount = (bEager ? this->getDataCount() : 0);
    00092       long lOffsetSoftDelete = (bEager ? (this->m_oSoftDelete.isEmpty() ? 0 : 1) : 0);
    00093       params.setOffset(params.offset() + lOffsetDataMember + lOffsetDataId + lOffsetDataCount + lOffsetSoftDelete);
    00094    }
    00095
    00096    virtual void createTable(QxSqlRelationParams & params) const
    00097    {
    00098       QString & sql = params.sql();
    00099       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00100       if (pData) { sql += pData->getSqlNameAndTypeAndParams(", ") + ", "; qAssert(! pData->getSqlType().isEmpty()); }
    00101    }
    00102
    00103    virtual void lazySelect(QxSqlRelationParams & params) const
    00104    {
    00105       QString & sql = params.sql();
    00106       QString tableRef = params.builder().table();
    00107       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00108       if (pData) { sql += (pData->getSqlTablePointNameAsAlias(tableRef) + ", "); }
    00109    }
    00110
    00111    virtual void eagerSelect(QxSqlRelationParams & params) const
    00112    {
    00113       long l1(0);
    00114       QString & sql = params.sql();
    00115       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00116       IxDataMember * p = NULL; IxDataMember * pId = this->getDataId(); qAssert(pId);
    00117       QString table = this->table(); QString tableAlias = this->tableAlias(params); QString tableRef = params.builder().table();
    00118       if (pData) { sql += (pData->getSqlTablePointNameAsAlias(tableRef) + ", "); }
    00119       if (pId) { sql += (pId->getSqlTablePointNameAsAlias(tableAlias) + ", "); }
    00120       while ((p = this->nextData(l1))) { sql += (p->getSqlTablePointNameAsAlias(tableAlias) + ", "); }
    00121       if (! this->m_oSoftDelete.isEmpty()) { sql += (this->m_oSoftDelete.buildSqlTablePointName(tableAlias) + ", "); }
    00122    }
    00123
    00124    virtual void eagerJoin(QxSqlRelationParams & params) const
    00125    {
    00126       QString & sql = params.sql();
    00127       IxDataMember * pId = this->getDataId(); qAssert(pId);
    00128       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00129       QString table = this->table(); QString tableAlias = this->tableAlias(params); QString tableRef = params.builder().table();
    00130       if (! pId || ! pData) { return; }
    00131       sql += this->getSqlJoin() + table + " " + tableAlias + " ON ";
    00132       for (int i = 0; i < pId->getNameCount(); i++)
    00133       { sql += pId->getSqlAlias(tableAlias, true, i) + " = " + pData->getSqlAlias(tableRef, true, i) + " AND "; }
    00134       sql = sql.left(sql.count() - 5); // Remove last " AND "
    00135    }
    00136
    00137    virtual void eagerWhereSoftDelete(QxSqlRelationParams & params) const
    00138    {
    00139       if (this->m_oSoftDelete.isEmpty()) { return; }
    00140       QString & sql = params.sql();
    00141       QString tableAlias = this->tableAlias(params);
    00142       sql += qx::IxSqlQueryBuilder::addSqlCondition(sql);
    00143       sql += this->m_oSoftDelete.buildSqlQueryToFetch(tableAlias);
    00144    }
    00145
    00146    virtual void lazyFetch_ResolveOutput(QxSqlRelationParams & params) const
    00147    {
    00148       if (! this->verifyOffset(params, false)) { return; }
    00149       QSqlQuery & query = params.query();
    00150       typename QxSqlRelation<DataType, Owner>::type_owner & currOwner = this->getOwner(params);
    00151       IxDataMember * pData = this->getDataMember(); qAssert(pData); if (! pData) { return; }
    00152       for (int i = 0; i < pData->getNameCount(); i++)
    00153       { QVariant vId = query.value(params.offset() + i); pData->fromVariant((& currOwner), vId, i); }
    00154       this->updateOffset(false, params);
    00155    }
    00156
    00157    virtual void eagerFetch_ResolveOutput(QxSqlRelationParams & params) const
    00158    {
    00159       if (! this->verifyOffset(params, false)) { return; }
    00160       QSqlQuery & query = params.query();
    00161       typename QxSqlRelation<DataType, Owner>::type_owner & currOwner = this->getOwner(params);
    00162       IxDataMember * pData = this->getDataMember(); qAssert(pData); if (! pData) { return; }
    00163       IxDataMember * p = NULL; IxDataMember * pId = this->getDataId(); qAssert(pId); if (! pId) { return; }
    00164       long lIndex = 0; long lOffsetId = (pId ? pId->getNameCount() : 0); long lOffsetData = (pData ? pData->getNameCount() : 0);
    00165       long lOffsetOld = params.offset(); this->updateOffset(true, params);
    00166       long lOffsetRelation = (lOffsetOld + lOffsetId + lOffsetData);
    00167       bool bValidId(false), bValidIdBis(false);
    00168       for (int i = 0; i < pData->getNameCount(); i++)
    00169       { QVariant vId = query.value(lOffsetOld + i); bValidId = (bValidId || qx::trait::is_valid_primary_key(vId)); }
    00170       for (int i = 0; i < pId->getNameCount(); i++)
    00171       { QVariant vIdBis = query.value(lOffsetOld + lOffsetData + i); bValidIdBis = (bValidIdBis || qx::trait::is_valid_primary_key(vIdBis)); }
    00172       if (pData && bValidId) { for (int i = 0; i < pData->getNameCount(); i++) { pData->fromVariant((& currOwner), query.value(lOffsetOld + i), i); } }
    00173       if (! bValidIdBis) { return; }
    00174       type_data & currData = this->getData(params);
    00175       if (pId) { for (int i = 0; i < pId->getNameCount(); i++) { pId->fromVariant((& currData), query.value(lOffsetOld + lOffsetData + i), i); } }
    00176       while ((p = this->nextData(lIndex)))
    00177       { p->fromVariant((& currData), query.value(lOffsetRelation++)); }
    00178    }
    00179
    00180    virtual void lazyInsert(QxSqlRelationParams & params) const
    00181    {
    00182       QString & sql = params.sql();
    00183       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00184       if (pData) { sql += pData->getSqlName(", ") + ", "; }
    00185    }
    00186
    00187    virtual void lazyInsert_Values(QxSqlRelationParams & params) const
    00188    {
    00189       QString & sql = params.sql();
    00190       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00191       if (pData) { sql += pData->getSqlPlaceHolder("", -1, ", ") + ", "; }
    00192    }
    00193
    00194    virtual void lazyUpdate(QxSqlRelationParams & params) const
    00195    {
    00196       QString & sql = params.sql();
    00197       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00198       if (pData) { sql += pData->getSqlNameEqualToPlaceHolder("", ", ") + ", "; }
    00199    }
    00200
    00201    virtual void lazyInsert_ResolveInput(QxSqlRelationParams & params) const
    00202    {
    00203       QSqlQuery & query = params.query();
    00204       typename QxSqlRelation<DataType, Owner>::type_owner & currOwner = this->getOwner(params);
    00205       IxDataMember * pData = this->getDataMember(); qAssert(pData);
    00206       if (pData) { pData->setSqlPlaceHolder(query, (& currOwner)); }
    00207    }
    00208
    00209 };
    00210
    00211 } // namespace qx
    00212
    00213 #endif // _QX_SQL_RELATION_MANY_TO_ONE_H_

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines