open_source / orm

Commit 5251bf3a4b053b7e27754dce13ada5611ba6582b

Authored by Steven de Ridder 2022-01-25 09:20:16 +0100

0 parents

Initial commit. dependencies not resolved yet.

.gitignore 0 → 100644

		1	+++ a/.gitignore
		1	+build/
		2	+CMakeLists.txt.user

CMakeLists.txt 0 → 100644

View file @5251bf3

		1	+++ a/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+
		3	+# Check to see where cmake is located.
		4	+if( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/cmake )
		5	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
		6	+elseif( IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../cmake )
		7	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
		8	+else()
		9	+ return()
		10	+endif()
		11	+
		12	+# Check to see if there is versioning information available
		13	+if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
		14	+ LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/osdev_versioning/cmake)
		15	+ include(osdevversion)
		16	+endif()
		17	+
		18	+include(projectheader)
		19	+project_header(osdev_orm)
		20	+
		21	+add_subdirectory(src)
		22	+add_subdirectory(tests)
		23	+
		24	+# include(packaging)
		25	+# package_component()

README.md 0 → 100644

View file @5251bf3

+++ a/README.md

src/CMakeLists.txt 0 → 100644

View file @5251bf3

		1	+++ a/src/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+include(projectheader)
		3	+project_header(orm)
		4	+
		5	+find_package( Qt5Core REQUIRED )
		6	+find_package( Qt5Sql REQUIRED )
		7	+
		8	+include_directories( SYSTEM
		9	+ ${Qt5Core_INCLUDE_DIRS}
		10	+ ${Qt5Sql_INCLUDE_DIRS}
		11	+)
		12	+
		13	+include(compiler)
		14	+
		15	+include_directories(
		16	+ ${CMAKE_CURRENT_SOURCE_DIR}/../config
		17	+ ${CMAKE_CURRENT_SOURCE_DIR}/../global
		18	+ ${CMAKE_CURRENT_SOURCE_DIR}/../logutils
		19	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../interfaces
		20	+ ${CMAKE_CURRENT_SOURCE_DIR}/../datatypes
		21	+ ${CMAKE_CURRENT_SOURCE_DIR}/../dbconnector
		22	+ ${CMAKE_CURRENT_SOURCE_DIR}/../transqueue
		23	+ ${CMAKE_CURRENT_SOURCE_DIR}/../pugixml
		24	+)
		25	+
		26	+set(SRC_LIST
		27	+ ${CMAKE_CURRENT_SOURCE_DIR}/multisortfilterproxymodel.cpp
		28	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormhandler.cpp
		29	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormthread.cpp
		30	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormtable.cpp
		31	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormtablerow.cpp
		32	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormbatchchange.cpp
		33	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormbatchchange.h
		34	+ ${CMAKE_CURRENT_SOURCE_DIR}/multisortfilterproxymodel.h
		35	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormhandler.h
		36	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormthread.h
		37	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormtable.h
		38	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormtablerow.h
		39	+ ${CMAKE_CURRENT_SOURCE_DIR}/timeline.cpp
		40	+ ${CMAKE_CURRENT_SOURCE_DIR}/timeline.h
		41	+ ${CMAKE_CURRENT_SOURCE_DIR}/timestamp.cpp
		42	+ ${CMAKE_CURRENT_SOURCE_DIR}/timestamp.h
		43	+)
		44	+
		45	+include(qtmoc)
		46	+create_mocs( SRC_LIST MOC_LIST
		47	+ ${CMAKE_CURRENT_SOURCE_DIR}/multisortfilterproxymodel.h
		48	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormhandler.h
		49	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormthread.h
		50	+ ${CMAKE_CURRENT_SOURCE_DIR}/ormtable.h
		51	+)
		52	+
		53	+link_directories(
		54	+ ${CMAKE_BINARY_DIR}/lib
		55	+)
		56	+
		57	+include(library)
		58	+add_libraries(
		59	+ ${Qt5Core_LIBRARIES}
		60	+ ${Qt5Sql_LIBRARIES}
		61	+ global
		62	+ logutils
		63	+ datatypes
		64	+ dbconnector
		65	+ transqueue
		66	+)
		67	+
		68	+include(installation)
		69	+install_component()

src/multisortfilterproxymodel.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/multisortfilterproxymodel.cpp
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+#include "multisortfilterproxymodel.h"
		23	+
		24	+#include "log.h"
		25	+
		26	+#include <QDebug>
		27	+
		28	+using namespace osdev::components;
		29	+
		30	+MultiSortFilterProxyModel::MultiSortFilterProxyModel(QObject* _parent)
		31	+ : QSortFilterProxyModel(_parent)
		32	+ , m_columnPatterns()
		33	+{
		34	+}
		35	+
		36	+void MultiSortFilterProxyModel::setFilterKeyColumns(const QList<qint32> &filterColumns)
		37	+{
		38	+ m_columnPatterns.clear();
		39	+ foreach(qint32 column, filterColumns)
		40	+ {
		41	+ m_columnPatterns.insert(column, QString()); // Add columns with empty patterns
		42	+ }
		43	+}
		44	+
		45	+void MultiSortFilterProxyModel::setFilterFixedString(qint32 column, const QString &pattern)
		46	+{
		47	+ if(!m_columnPatterns.contains(column))
		48	+ {
		49	+ return;
		50	+ }
		51	+
		52	+ m_columnPatterns[column] = pattern;
		53	+}
		54	+
		55	+bool MultiSortFilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
		56	+{
		57	+ if(m_columnPatterns.isEmpty())
		58	+ {
		59	+ return true; // No pattern -> accept all
		60	+ }
		61	+
		62	+ for(QMap<qint32, QString>::const_iterator iter = m_columnPatterns.constBegin(); iter != m_columnPatterns.constEnd(); ++iter)
		63	+ {
		64	+ QModelIndex idx = sourceModel()->index(sourceRow, iter.key(), sourceParent);
		65	+ if (idx.data().toString() != iter.value())
		66	+ {
		67	+ return false;
		68	+ }
		69	+ }
		70	+ return true;
		71	+}

src/multisortfilterproxymodel.h 0 → 100644

View file @5251bf3

		1	+++ a/src/multisortfilterproxymodel.h
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+
		23	+#ifndef OSDEV_COMPONENTS_MULTISORTFILTERPROXYMODEL_H
		24	+#define OSDEV_COMPONENTS_MULTISORTFILTERPROXYMODEL_H
		25	+
		26	+#include <QObject>
		27	+#include <QMap>
		28	+#include <QSortFilterProxyModel>
		29	+#include <QString>
		30	+
		31	+namespace osdev {
		32	+namespace components {
		33	+
		34	+//! @brief Filter that can filter a model on multiple columns.
		35	+//! @note Do not mix uasge of setFilterKeyColumns and setFilterKeyColumn.
		36	+class MultiSortFilterProxyModel : public QSortFilterProxyModel
		37	+{
		38	+ Q_OBJECT
		39	+
		40	+public:
		41	+ explicit MultiSortFilterProxyModel(QObject* parent = 0);
		42	+
		43	+ //! @brief Set the columns to filter on.
		44	+ //! This will overwrite the previous filter settings (including the patterns).
		45	+ void setFilterKeyColumns(const QList<qint32>& filterColumns);
		46	+
		47	+ //! @brief Add a pattern on a specific column index.
		48	+ //! If the index is not known the pattern is not applied.
		49	+ void setFilterFixedString(qint32 column, const QString& pattern);
		50	+
		51	+protected:
		52	+ //! @brief Called from the base class to do the actual filtering.
		53	+ virtual bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const;
		54	+
		55	+private:
		56	+ QMap<qint32, QString> m_columnPatterns; ///< holds the filter pattern for column indices.
		57	+};
		58	+
		59	+} // End namespace components
		60	+} // End namespace osdev
		61	+
		62	+#endif // OSDEV_COMPONENTS_MULTISORTFILTERPROXYMODEL_H

src/ormbatchchange.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormbatchchange.cpp
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+#include "ormbatchchange.h"
		23	+#include "log.h"
		24	+#include <algorithm>
		25	+
		26	+using namespace osdev::components;
		27	+
		28	+OrmBatchChange::OrmBatchChange()
		29	+ : m_changeTimestamp()
		30	+ , m_foreignId()
		31	+ , m_changeSet()
		32	+ , m_valid(false)
		33	+{
		34	+}
		35	+
		36	+OrmBatchChange::OrmBatchChange(const Timestamp& ts, const QVariant& _foreignId, const std::set<QVariant>& _changeSet)
		37	+ : m_changeTimestamp(ts)
		38	+ , m_foreignId(_foreignId)
		39	+ , m_changeSet(_changeSet)
		40	+ , m_valid(!_foreignId.isNull() && ts.valid())
		41	+{
		42	+ if (!m_valid)
		43	+ {
		44	+ LogInfo("[OrmBatchChange ctor]", QString("Change is invalid : Timestamp %1, foreignId::isNull %2").arg(m_changeTimestamp.toString()).arg(m_foreignId.isNull()));
		45	+ }
		46	+}
		47	+
		48	+bool OrmBatchChange::processChange(const OrmBatchChange& change, bool exclusiveUpdate)
		49	+{
		50	+ LogDebug("[OrmBatchChange::processChange]", QString("Check %1 against change with timestamp %2, exlusiveUpdate is %3")
		51	+ .arg(m_changeTimestamp.toString())
		52	+ .arg(change.timestamp().toString())
		53	+ .arg(exclusiveUpdate));
		54	+ if (!m_valid)
		55	+ {
		56	+ LogInfo("[OrmBatchChange::processChange]", "Incoming change is invalid");
		57	+ return false; // This is an invalid change and can never become valid so signal to stop processing.
		58	+ }
		59	+
		60	+ if (*this < change)
		61	+ {
		62	+ if (exclusiveUpdate && (change.m_foreignId == m_foreignId))
		63	+ {
		64	+ // this change is not necessary because it is already superseded. Invalidate it and signal to stop processing.
		65	+ LogInfo("[OrmBatchChange::processChange]", "Change is superseded by newer change");
		66	+ m_valid = false;
		67	+ return false;
		68	+ }
		69	+
		70	+ // Find the items that are in the incoming change but not in the already applied change that we are checking against.
		71	+ // These items still need to change w.r.t to this change.
		72	+ if (!m_changeSet.empty())
		73	+ {
		74	+ std::set<QVariant> result;
		75	+ std::set_difference(m_changeSet.begin(), m_changeSet.end(), change.m_changeSet.begin(), change.m_changeSet.end(), std::inserter(result, result.begin()));
		76	+ m_changeSet.swap(result);
		77	+ }
		78	+
		79	+ // If the changeset is empty and the update is not exclusive then nothing has to be done.
		80	+ // In case of an exclusive update an empty set means that none of the items can point to the given foreignId
		81	+ // and processing needs to be continued.
		82	+ if (!exclusiveUpdate && m_changeSet.empty())
		83	+ {
		84	+ // Invalidate the incoming change and signal to stop processing.
		85	+ LogInfo("[OrmBatchChange::processChange]", "Nothing to do for non exclusive update");
		86	+ m_valid = false;
		87	+ return false;
		88	+ }
		89	+ }
		90	+ return true;
		91	+}
		92	+
		93	+// static
		94	+std::set<QVariant> OrmBatchChange::toSet(const QList<QVariant>& lst)
		95	+{
		96	+ std::set<QVariant> result;
		97	+ for (const auto& item : lst)
		98	+ {
		99	+ result.insert(item);
		100	+ }
		101	+ return result;
		102	+}
		103	+
		104	+// static
		105	+QList<QVariant> OrmBatchChange::toList(const std::set<QVariant>& s)
		106	+{
		107	+ QList<QVariant> result;
		108	+ for (const auto& item : s)
		109	+ {
		110	+ result.push_back(item);
		111	+ }
		112	+ return result;
		113	+}
		114	+

src/ormbatchchange.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormbatchchange.h
		1	+#ifndef OSDEV_COMPONENTS_ORMBATCHCHANGE_H
		2	+#define OSDEV_COMPONENTS_ORMBATCHCHANGE_H
		3	+
		4	+#include <set>
		5	+
		6	+#include <QVariant>
		7	+
		8	+#include "timestamp.h"
		9	+
		10	+namespace osdev {
		11	+namespace components {
		12	+
		13	+/**
		14	+ * @brief Describes a change that should happen or has happened on a BatchUpdate or MergeUpdate table.
		15	+ */
		16	+class OrmBatchChange
		17	+{
		18	+public:
		19	+ /**
		20	+ * @brief Creates an invalid OrmBatchChange.
		21	+ * @note The only way to make an OrmBatchChange valid is by assigning a valid OrmBatchChange to it.
		22	+ */
		23	+ OrmBatchChange();
		24	+
		25	+ /**
		26	+ * @brief Create an OrmBatchChange with a change description.
		27	+ * @param ts A valid timestamp (not checked).
		28	+ * @param foreignId The value that should be pointed to.
		29	+ * @param changeSet The set of record identifiers of records that should point to the given foreignId.
		30	+ */
		31	+ OrmBatchChange(const Timestamp& ts, const QVariant& foreignId, const std::set<QVariant>& changeSet);
		32	+
		33	+ // Default copyable and movable.
		34	+ OrmBatchChange(const OrmBatchChange&) = default;
		35	+ OrmBatchChange& operator=(const OrmBatchChange&) = default;
		36	+ OrmBatchChange(OrmBatchChange&&) = default;
		37	+ OrmBatchChange& operator=(OrmBatchChange&&) = default;
		38	+
		39	+ /**
		40	+ * @brief Process an already executed change on this change.
		41	+ * The changeset of this object can be reshaped as a result.
		42	+ * @param change A known change.
		43	+ * @param exclusiveUpdate Flag that indicates if the change should be processed in an exclusive way.
		44	+ * @return true to indicate this change is still valid and false otherwise.
		45	+ * @note An exclusiveUpdate means that all records that are not mentioned in the change set will not point to the given foreignId.
		46	+ */
		47	+ bool processChange(const OrmBatchChange& change, bool exclusiveUpdate);
		48	+
		49	+ /**
		50	+ * @brief Changes are ordered w.r.t. each other by their timestamp.
		51	+ */
		52	+ bool operator<(const OrmBatchChange& rhs) const
		53	+ {
		54	+ return m_changeTimestamp < rhs.m_changeTimestamp;
		55	+ }
		56	+
		57	+ /**
		58	+ * @brief Change the timestamp of this change.
		59	+ * This is necessary when the change is recorded to be permanent. It then becomes the latest change.
		60	+ * @param ts The new timestamp (no checks).
		61	+ */
		62	+ void setTimestamp(const Timestamp& ts)
		63	+ {
		64	+ m_changeTimestamp = ts;
		65	+ }
		66	+
		67	+ /**
		68	+ * @return The timestamp of this change.
		69	+ */
		70	+ const Timestamp& timestamp() const
		71	+ {
		72	+ return m_changeTimestamp;
		73	+ }
		74	+
		75	+ /**
		76	+ * @return The foreinId of this change.
		77	+ */
		78	+ QVariant foreignId() const
		79	+ {
		80	+ return m_foreignId;
		81	+ }
		82	+
		83	+ /**
		84	+ * @return The change set of this change.
		85	+ */
		86	+ std::set<QVariant> changeSet() const
		87	+ {
		88	+ return m_changeSet;
		89	+ }
		90	+
		91	+ /**
		92	+ * @return true if this change is valid, false otherwise.
		93	+ */
		94	+ bool valid() const
		95	+ {
		96	+ return m_valid;
		97	+ }
		98	+
		99	+ /**
		100	+ * @brief Static method to convert a QList<QVariant> to an std::set<QVariant>.
		101	+ * @param lst The QList<QVariant> to convert.
		102	+ * @return the converted set.
		103	+ */
		104	+ static std::set<QVariant> toSet(const QList<QVariant>& lst);
		105	+
		106	+ /**
		107	+ * @brief Static method to convert an std::set<QVariant> to a QList<QVariant>.
		108	+ * @param variantSet The set of variants to convert.
		109	+ * @return the converted QList.
		110	+ */
		111	+ static QList<QVariant> toList(const std::set<QVariant>& variantSet);
		112	+
		113	+private:
		114	+ Timestamp m_changeTimestamp; ///< The timestamp of this change.
		115	+ QVariant m_foreignId; ///< The foreignId that should be pointed to.
		116	+ std::set<QVariant> m_changeSet; ///< The set of record identifiers that describe the change.
		117	+ bool m_valid; ///< Flag that indicates if this change is valid.
		118	+};
		119	+
		120	+} /* End namespace components */
		121	+} /* End namespace osdev */
		122	+
		123	+#endif /* OSDEV_COMPONENTS_ORMBATCHCHANGE_H */

src/ormhandler.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormhandler.cpp
		1	+#include "ormhandler.h"
		2	+#include "dcxmlconfig.h"
		3	+#include "log.h"
		4	+#include "dbrelation.h"
		5	+#include "threadcontext.h"
		6	+
		7	+#include <QSqlRecord>
		8	+#include <QSqlField>
		9	+#include <QSqlRelation>
		10	+#include <QSqlIndex>
		11	+
		12	+#include <QtDebug>
		13	+
		14	+using namespace osdev::components;
		15	+
		16	+typedef QList<DbRelation*> Relations;
		17	+
		18	+OrmHandler::OrmHandler(QObject *_parent)
		19	+ : QObject( _parent )
		20	+ , m_qhOrmTables()
		21	+ , m_dbConnection()
		22	+ , m_className( "OrmHandler" )
		23	+{
		24	+ m_dbConnection.setCredentials( DCXmlConfig::Instance().getDbCredentials() );
		25	+
		26	+ // Check if a watchdog is required and connect those. If a database goes offline, all data should be redirected to the TransQueue.
		27	+ if( DCXmlConfig::Instance().getEnableDbWatchDog() )
		28	+ {
		29	+ // Start the watchdog and set the interval.
		30	+ m_dbConnection.startDbWatchDog( DCXmlConfig::Instance().getDbCheckInterval() );
		31	+ }
		32	+}
		33	+
		34	+OrmHandler::~OrmHandler()
		35	+{
		36	+}
		37	+
		38	+void OrmHandler::start()
		39	+{
		40	+ // connect the database.
		41	+ LogInfo( m_className, "Connecting to database.." );
		42	+ if( m_dbConnection.connectDatabase() )
		43	+ {
		44	+ // Read configuration
		45	+ QStringList tableList = DCXmlConfig::Instance().getOrmTables();
		46	+
		47	+ if( 0 == tableList.count() )
		48	+ {
		49	+ tableList = m_dbConnection.getTableNames();
		50	+ }
		51	+
		52	+ LogInfo( m_className,
		53	+ QString("Connected to database %1") .arg( m_dbConnection.getDatabaseName() ) );
		54	+
		55	+ // First make sure we have all tables created, before we create all relations...
		56	+ for( const QString& tableName : tableList )
		57	+ {
		58	+ createOrmObject( tableName );
		59	+ }
		60	+ // -------------------------------------------------
		61	+ // Create all relations on the same list of tables.
		62	+ for( const QString& tableName : tableList )
		63	+ {
		64	+ QString status;
		65	+ // If creation of the object succeeded it is safe to add the relations.
		66	+ switch( createOrmRelation( tableName ) )
		67	+ {
		68	+ case OrmStatus::OrmStatusFailed:
		69	+ status = "failed.";
		70	+ break;
		71	+ case OrmStatus::OrmStatusNoRelation:
		72	+ status = "not created (As there are none.)";
		73	+ break;
		74	+ case OrmStatus::OrmStatusSuccess:
		75	+ status = "succeeded.";
		76	+ break;
		77	+ }
		78	+ LogInfo( "[OrmHandler::start]", QString( "Creation of ORM Relation for table : %1 %2" ).arg( tableName ).arg( status ) );
		79	+ }
		80	+ }
		81	+ else
		82	+ {
		83	+ LogInfo( m_className,
		84	+ QString( "Connection to database %1 failed with error : %2" )
		85	+ .arg( m_dbConnection.getDatabaseName() )
		86	+ .arg( m_dbConnection.getLastError() ) );
		87	+
		88	+ //@todo : This will produce a SegmentationFault for now due to mutlihreaded pluginloading.
		89	+ // This should be fixed in future releases by implementing a nice rolldown with locking
		90	+ // mechanisms and shutdown events.
		91	+ QMetaObject::invokeMethod( qApp, "quit", Qt::QueuedConnection );
		92	+ }
		93	+}
		94	+
		95	+bool OrmHandler::createOrmObject( const QString& _table )
		96	+{
		97	+ bool l_result = false;
		98	+
		99	+ OrmTable *pModel = new OrmTable( m_dbConnection, this );
		100	+ if ( pModel )
		101	+ {
		102	+ pModel->setTrackField( DCXmlConfig::Instance().getRecordTrackFieldName() );
		103	+ pModel->setTable( m_dbConnection.quoteTableName( _table ) );
		104	+ m_qhOrmTables.insert( _table, pModel );
		105	+
		106	+ // cascade connect the rejectedsignal.
		107	+ connect( pModel, &OrmTable::signalRejectedData, this, &OrmHandler::signalRejectedData );
		108	+ l_result = true;
		109	+ }
		110	+
		111	+ return l_result;
		112	+}
		113	+
		114	+OrmHandler::OrmStatus OrmHandler::createOrmRelation( const QString& _table )
		115	+{
		116	+ OrmStatus ormResult = OrmStatus::OrmStatusFailed;
		117	+
		118	+ Relations lstRelations = m_dbConnection.getRelationByTableName( _table );
		119	+ if( lstRelations.isEmpty() )
		120	+ {
		121	+ return OrmStatus::OrmStatusNoRelation;
		122	+ }
		123	+
		124	+ // Each relation found should be added to the table.
		125	+ for( auto& relation : lstRelations )
		126	+ {
		127	+ // Save the relation to the table administration.
		128	+ m_qhOrmTables.value( _table )->saveRelation( relation->constraintName(), relation );
		129	+
		130	+ // Create a QSortProxyFilterModel and add to the table.
		131	+ QSortFilterProxyModel *pModel = new QSortFilterProxyModel();
		132	+
		133	+ pModel->setSourceModel( m_qhOrmTables.value( relation->foreignTable() ) );
		134	+ m_qhOrmTables.value( _table )->setRelatedTable( relation->foreignTable(), pModel );
		135	+ }
		136	+
		137	+ // Check if the number of relations found is equal to the number of relations
		138	+ // added to the ORM-table.
		139	+ if( lstRelations.count() == m_qhOrmTables.value( _table )->numberOfRelations() )
		140	+ {
		141	+ ormResult = OrmStatus::OrmStatusSuccess;
		142	+ }
		143	+ else
		144	+ {
		145	+ LogDebug( "[OrmHandler::createOrmRelation]", QString( "Number of relations : %1 => Number of relations registered : %2" ).arg( lstRelations.count() ).arg( m_qhOrmTables.value( _table )->numberOfRelations() ) );
		146	+ ormResult = OrmStatus::OrmStatusFailed;
		147	+ }
		148	+
		149	+ return ormResult;
		150	+}
		151	+
		152	+void OrmHandler::receiveData( const QSharedPointer<ORMRelData>& dataContainer )
		153	+{
		154	+ ThreadContextScope tcs( dataContainer->traceId() );
		155	+ LogDebug( "[OrmHandler::receiveData]", dataContainer->asString() );
		156	+ // Check if we have an actual database running. if it died, redirect immediately
		157	+ if( m_dbConnection.isOpen() )
		158	+ {
		159	+ if( m_qhOrmTables.contains( dataContainer->getMainTableName() ) )
		160	+ {
		161	+ LogDebug("[OrmHandler::receiveData]", QString("Table entry found for %1").arg( dataContainer->getMainTableName() ) );
		162	+ m_qhOrmTables.value( dataContainer->getMainTableName() )->writeData( dataContainer );
		163	+ }
		164	+ else
		165	+ {
		166	+ LogWarning("[OrmHandler::receiveData]", QString("No table entry found for %1").arg( dataContainer->getMainTableName() ) );
		167	+ emit signalRejectedData( dataContainer );
		168	+ }
		169	+ }
		170	+ else
		171	+ {
		172	+ emit signalRejectedData( dataContainer );
		173	+ }
		174	+}
		175	+
		176	+QString OrmHandler::getPrimaryKey( const QString& tableName ) const
		177	+{
		178	+ if( m_qhOrmTables.contains( tableName ) )
		179	+ {
		180	+ return m_qhOrmTables.value( tableName )->primaryKey().name();
		181	+ }
		182	+ return QString();
		183	+}

src/ormhandler.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormhandler.h
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+#ifndef OSDEV_COMPONENTS_ORMHANDLER_H
		23	+#define OSDEV_COMPONENTS_ORMHANDLER_H
		24	+
		25	+#include <memory>
		26	+
		27	+#include <QObject>
		28	+#include <QHash>
		29	+#include <QSharedPointer>
		30	+#include <QString>
		31	+
		32	+#include "dbconnector.h"
		33	+#include "ormtable.h"
		34	+#include "ormreldata.h"
		35	+
		36	+namespace osdev {
		37	+namespace components {
		38	+
		39	+/**
		40	+ * @brief Handles the Object Relational Model
		41	+ */
		42	+class OrmHandler : public QObject
		43	+{
		44	+ Q_OBJECT
		45	+
		46	+public:
		47	+ enum class OrmStatus
		48	+ {
		49	+ OrmStatusSuccess = 0,
		50	+ OrmStatusNoRelation,
		51	+ OrmStatusFailed
		52	+ };
		53	+
		54	+ /**
		55	+ * @brief Constructor
		56	+ * @param parent Parent QObject
		57	+ */
		58	+ explicit OrmHandler(QObject *parent = nullptr);
		59	+
		60	+ /// Deleted copy-constructor
		61	+ OrmHandler(const OrmHandler&) = delete;
		62	+ /// Deleted assignment operator
		63	+ OrmHandler& operator=(const OrmHandler&) = delete;
		64	+ /// Deleted move-constructor
		65	+ OrmHandler(const OrmHandler&&) = delete;
		66	+ /// Deleted move operator
		67	+ OrmHandler& operator=(const OrmHandler&&) = delete;
		68	+
		69	+ virtual ~OrmHandler();
		70	+
		71	+ /// @brief Start the ORM handler
		72	+ void start();
		73	+
		74	+public slots:
		75	+ /**
		76	+ * @brief Receive data from an external source
		77	+ * @param dataContainer - Data received Each layer has shared ownership of the
		78	+ * pointer it receives. (See SSD @TODO Actualy SSD needs updating on this issue.)
		79	+ */
		80	+ void receiveData( const QSharedPointer<ORMRelData>& dataContainer );
		81	+
		82	+ /*!
		83	+ * \brief Gets the primary key from the given tableName
		84	+ * \param tableName - The table we're interested in.
		85	+ * \return The primary keyfield name.
		86	+ */
		87	+ QString getPrimaryKey( const QString& tableName ) const;
		88	+
		89	+signals:
		90	+ /*!
		91	+ * \brief Signal for RejectedData.
		92	+ * \param dataContainer The data container for this signal.
		93	+ */
		94	+ void signalRejectedData( const QSharedPointer<ORMRelData>& dataContainer );
		95	+
		96	+private:
		97	+ /**
		98	+ * @brief Create an Object Relational Model object for a specific table
		99	+ * @param _table Table name
		100	+ * @return True if successful, false otherwise
		101	+ */
		102	+ bool createOrmObject( const QString& _table );
		103	+
		104	+ /*!
		105	+ * \brief Create an ORM object for a specific relation or constraint.
		106	+ *
		107	+ * \param table The name of the table for which to create an ORM relation.
		108	+ * \return true if the object was created. False if something went wrong.
		109	+ */
		110	+ OrmStatus createOrmRelation( const QString& table );
		111	+
		112	+ // Internal structures and objects.
		113	+ QHash<QString, OrmTable> m_qhOrmTables; ///< Maps table-name to TableModel
		114	+ DbConnector m_dbConnection; ///< Database connection
		115	+ QString m_className; ///< Name of the class for logging purposes
		116	+};
		117	+
		118	+} // End namespace components
		119	+} // End namespace osdev
		120	+
		121	+#endif // OSDEV_COMPONENTS_ORMHANDLER_H

src/ormtable.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtable.cpp
		1	+#include "ormdata.h"
		2	+#include "ormtable.h"
		3	+#include "ormhandler.h"
		4	+#include "log.h"
		5	+#include "multisortfilterproxymodel.h"
		6	+
		7	+#include <QSqlError>
		8	+#include <QSqlRecord>
		9	+#include <QSqlField>
		10	+#include <QSqlQuery>
		11	+
		12	+#include <QtDebug>
		13	+#include <QtCore/qnamespace.h>
		14	+
		15	+using namespace osdev::components;
		16	+
		17	+OrmTable::OrmTable(const DbConnector &db, QObject *_parent)
		18	+ : QSqlRelationalTableModel( _parent, db.getDatabase() )
		19	+ , m_className( "OrmTable" )
		20	+ , m_recTrackField()
		21	+ , m_db( db )
		22	+ , m_qhRelTables()
		23	+ , m_qhRelations()
		24	+ , m_qhFieldTypes()
		25	+ , m_qhTimelines()
		26	+{
		27	+ if ( !QSqlRelationalTableModel::database().isOpen() )
		28	+ {
		29	+ LogWarning( m_className, "Database is closed.");
		30	+ }
		31	+}
		32	+
		33	+OrmTable::~OrmTable()
		34	+{
		35	+}
		36	+
		37	+void OrmTable::setTable( const QString& _table )
		38	+{
		39	+ // Set tablename in the base class
		40	+ QSqlRelationalTableModel::setTable( m_db.quoteTableName( _table ) );
		41	+ m_className += "::" + this->tableName();
		42	+
		43	+ // Make every change being written to the database.
		44	+ QSqlRelationalTableModel::setEditStrategy( QSqlTableModel::OnRowChange );
		45	+
		46	+ // Now we know the tablename, we can retrieve the fieldtypes by their name. To prevent a functioncall
		47	+ // For each and every fieldname we're looking for, we store this in an internal Hash. Must be quicker than
		48	+ // then accessing the database layer.
		49	+ m_qhFieldTypes = m_db.getFieldNamesAndTypes( _table );
		50	+
		51	+ QSqlRecord _headerData = QSqlRelationalTableModel::database().record( m_db.quoteTableName( _table ) );
		52	+ for( int nCount = 0; nCount < _headerData.count(); nCount++ )
		53	+ {
		54	+ QSqlRelationalTableModel::setHeaderData( nCount, Qt::Horizontal, _headerData.fieldName(nCount) );
		55	+ }
		56	+
		57	+ // Now the table is set, headerinfo loaded and commit behaviour set :
		58	+ // Open the table and read from the database.
		59	+ QSqlRelationalTableModel::select();
		60	+}
		61	+
		62	+bool OrmTable::insertRecord( int _row, const QSqlRecord &_record )
		63	+{
		64	+ if ( QSqlRelationalTableModel::database().isOpen() )
		65	+ {
		66	+ LogDebug( m_className, "Database is open." );
		67	+ }
		68	+ else
		69	+ {
		70	+ LogWarning( m_className, "Database is closed." );
		71	+ }
		72	+
		73	+ bool b_result = QSqlRelationalTableModel::insertRecord( _row, _record );
		74	+
		75	+ if ( !b_result )
		76	+ {
		77	+ LogError( QString( "[OrmTable - %1]" ).arg( QSqlRelationalTableModel::tableName() ),
		78	+ QString( "Database gave error : %1")
		79	+ .arg( this->lastError().text() ) );
		80	+ }
		81	+
		82	+ return b_result;
		83	+}
		84	+
		85	+bool OrmTable::insertRecords(int row, const QList<QSqlRecord>& _records )
		86	+{
		87	+ bool l_bResult = true;
		88	+
		89	+ QSqlRelationalTableModel::setEditStrategy( QSqlTableModel::OnRowChange );
		90	+ for( const QSqlRecord& _record : _records )
		91	+ {
		92	+ l_bResult &= insertRecord( row, _record );
		93	+ }
		94	+ QSqlRelationalTableModel::submitAll();
		95	+
		96	+ // Reset the transaction method.
		97	+ QSqlRelationalTableModel::setEditStrategy( QSqlTableModel::OnRowChange );
		98	+
		99	+ return l_bResult;
		100	+}
		101	+
		102	+void OrmTable::writeData( const QSharedPointer<ORMRelData>& dataObject )
		103	+{
		104	+ // Reset the filter for this table before doing anything else
		105	+ this->resetFilter();
		106	+
		107	+ // Relations can be set on different fields. We have to take in account those
		108	+ // fields could be given in a list.
		109	+ ORMData* pMainTable = this->solveRelations( dataObject );
		110	+ if( nullptr == pMainTable \|\| pMainTable->getContainerName().isEmpty() )
		111	+ {
		112	+ LogDebug( "[OrmTable::writeData]", QString( "No maintable defined. Exiting..." ) );
		113	+ emit signalRejectedData( dataObject );
		114	+ return;
		115	+ }
		116	+
		117	+ bool updateSuccess = false;
		118	+ /// Here we check for the variable list. See if one of the variables is of type :
		119	+ /// QVariant( QList<Qvariant) ) Instead of a normal update, we should use
		120	+ /// a batched_update.
		121	+ if( pMainTable->hasLists() )
		122	+ {
		123	+ /// @todo: This is kind of a special case. For now we assume there is an inclusive
		124	+ /// and exclusive way of updating these records. All these updates should be done
		125	+ /// in a single transaction. The 'not-mentioned records' should be de-coupled.
		126	+ /// If those fail, the entire package should be rejected, including the ones that were
		127	+ /// mentioned. Default behaviour is "Each - change - a - transaction" so we need some
		128	+ /// extra precautions here.
		129	+
		130	+ // Check if all items in the list exist in the database. If not the package is rejected.
		131	+ if (!m_db.recordsExist(pMainTable->getContainerName(), pMainTable->getKeyField(), pMainTable->getValue( pMainTable->getKeyField() ).toList()))
		132	+ {
		133	+ LogInfo( "[OrmTable::writeData]", "Not all records are present. Package is rejected." );
		134	+ emit signalRejectedData( dataObject );
		135	+ return;
		136	+ }
		137	+
		138	+ // Set the TransactionScopeGuard. If it goes out-of-scope, for whatever reason,
		139	+ // it will do a Rollback if a transaction was started.
		140	+ OrmTransGuard l_scopeGuard;
		141	+
		142	+ // Check to see if the database supports transactions
		143	+ if( m_db.supportTransactions() )
		144	+ {
		145	+ if( !m_db.transactionBegin() )
		146	+ {
		147	+ LogDebug( "[OrmTable::writeData]", "Transaction failed to start." );
		148	+ emit signalRejectedData( dataObject );
		149	+ return;
		150	+ }
		151	+ l_scopeGuard = OrmTransGuard( m_db );
		152	+ }
		153	+
		154	+ std::unique_ptr<ORMData> mainTableCopy(pMainTable->clone());
		155	+ updateSuccess = batchUpdate( mainTableCopy.get(), dataObject->getSourceId() );
		156	+ if( !updateSuccess )
		157	+ {
		158	+ emit signalRejectedData( dataObject );
		159	+ return;
		160	+ }
		161	+
		162	+ if( ( static_cast<int>(TableActions::actionMergeUpdate) == mainTableCopy->getDefaultAction() )
		163	+ && ( !mainTableCopy->isMergeable() ) ) // If there is more than one key besides the keyfield, we cannot handle this (yet)
		164	+ {
		165	+ LogWarning( "[OrmTable::writeData]", QString( "Dataobject (ORMData) is not fit for mergeUpdate and is discarded : %1" ).arg( mainTableCopy->asString() ) );
		166	+ return;
		167	+ }
		168	+
		169	+ if( ( static_cast<int>(TableActions::actionMergeUpdate) == mainTableCopy->getDefaultAction() )
		170	+ && ( mainTableCopy->isMergeable() ) )
		171	+ {
		172	+ deCoupleRecords( mainTableCopy.get() );
		173	+ }
		174	+ else if (static_cast<int>(TableActions::actionUpdate) == mainTableCopy->getDefaultAction())
		175	+ {
		176	+ LogDebug( "[OrmTable::writeData]", QString( "Action is a \"normal\" update : %1" ).arg( mainTableCopy->asString() ) );
		177	+ }
		178	+
		179	+ if( !this->commit() )
		180	+ {
		181	+ emit signalRejectedData( dataObject );
		182	+ }
		183	+ auto timeline = m_qhTimelines[dataObject->getSourceId()];
		184	+ if (timeline)
		185	+ {
		186	+ timeline->commit();
		187	+ }
		188	+ return;
		189	+ }
		190	+ else
		191	+ {
		192	+ if( static_cast<int>(TableActions::actionUpdate) == pMainTable->getDefaultAction() )
		193	+ {
		194	+ // ===================================================================================
		195	+ // == S I N G L E R E C O R D U P D A T E ==
		196	+ // ===================================================================================
		197	+
		198	+ // See if we can actually update this record by checking its timestamp validity.
		199	+ //
		200	+ if( m_recTrackField.isEmpty() \|\| m_recTrackField.isNull() )
		201	+ {
		202	+ updateSuccess = this->updateRecord( pMainTable );
		203	+ }
		204	+ else
		205	+ {
		206	+ if( this->isPackageValid( pMainTable ) )
		207	+ {
		208	+ pMainTable->setValue( m_recTrackField, QVariant( pMainTable->timeStamp() ) );
		209	+ updateSuccess = this->updateRecord( pMainTable );
		210	+ }
		211	+ else
		212	+ {
		213	+ // Nope. Package is older. Discard.
		214	+ LogInfo( "[OrmTable::writeData]", QString( "Discarding package because it is older than information in the database" ) );
		215	+ return;
		216	+ }
		217	+ }
		218	+ }
		219	+
		220	+ if( updateSuccess )
		221	+ {
		222	+ return;
		223	+ }
		224	+ }
		225	+
		226	+ // ===================================================================================
		227	+ // == I N S E R T ==
		228	+ // ===================================================================================
		229	+ // If a timestamp is used in the database, add it to the table definition.
		230	+ if( !m_recTrackField.isEmpty() \|\| !m_recTrackField.isNull() )
		231	+ {
		232	+ pMainTable->setValue( m_recTrackField, pMainTable->timeStamp() );
		233	+ }
		234	+
		235	+
		236	+ // If we get to here, we're ready to create the new SQLRecord and add it to the table.
		237	+ QSqlRecord newRecord = this->buildSqlRecord( pMainTable );
		238	+ if( !newRecord.isEmpty() )
		239	+ {
		240	+ if( !m_db.createRecord( newRecord, this->tableName() ) )
		241	+ {
		242	+ // @todo : Change to a more database dependant, generic error checking based on keywords....
		243	+ if( this->lastError().text().contains( "violates unique constraint" ) \|\|
		244	+ this->lastError().text().contains( "violates not-null constraint" ) )
		245	+ {
		246	+ // Just drop the package and be done with it. This is a unique constraint violation
		247	+ LogDebug( "[OrmTable::writeData]", QString( "There was and error creating the record : %1" ).arg( this->lastError().text() ) );
		248	+ return;
		249	+ }
		250	+ else
		251	+ {
		252	+ LogDebug( "[OrmTable::writeData]", QString( "There was and error creating the record : %1" ).arg( this->lastError().text() ) );
		253	+ LogDebug( "[OrmTable::writeData]", "Deferring the datapackage to the TransQueue." );
		254	+ emit signalRejectedData( dataObject );
		255	+ }
		256	+
		257	+ }
		258	+ else
		259	+ {
		260	+ return;
		261	+ }
		262	+ }
		263	+ else
		264	+ {
		265	+ LogDebug( "[OrmTable::writeData]", QString( "Creating the new record failed.! : %1" ).arg( this->lastError().text() ) );
		266	+ }
		267	+}
		268	+
		269	+bool OrmTable::updateRecord( ORMData* dataObject )
		270	+{
		271	+
		272	+ auto lNumRecords = tableFilter( dataObject );
		273	+ if( lNumRecords > 1 )
		274	+ {
		275	+ LogError( "[OrmTable::updateRecord]", QString( "Multiple records found..." ) );
		276	+ return false;
		277	+ }
		278	+ else if( lNumRecords == 0 )
		279	+ {
		280	+ LogWarning( "[OrmTable::updateRecord]", QString( "No record found...Falling back to insert...." ) );
		281	+ return false;
		282	+ }
		283	+ else
		284	+ {
		285	+ // All criteria are met.. Time to update the record.
		286	+ // Each and and every field will be written, with the exception of the keyfield..
		287	+ // First get a list of all field names.
		288	+ bool updateSuccess = true;
		289	+ QStringList fieldNames = dataObject->getFieldNames();
		290	+ for( const QString& fieldName : fieldNames )
		291	+ {
		292	+ if( fieldName != dataObject->getKeyField() )
		293	+ {
		294	+ int colIndex = this->fieldIndex( fieldName );
		295	+ if( -1 == colIndex )
		296	+ {
		297	+ LogError( "[OrmTable::updateRecord]", QString( "No index found for : %1" ).arg( fieldName ) );
		298	+ }
		299	+ else
		300	+ {
		301	+ LogDebug( "[OrmTable::updateRecord]", QString( "Updating field : %1 (Index : %2) with value : %3" )
		302	+ .arg( fieldName )
		303	+ .arg( colIndex )
		304	+ .arg( dataObject->getValue( fieldName ).toString() ) );
		305	+
		306	+ this->setData( this->index( 0, colIndex ),
		307	+ ConversionUtils::convertToType(dataObject->getValue( fieldName ) ,m_qhFieldTypes.value( fieldName )),
		308	+ Qt::EditRole );
		309	+ }
		310	+ }
		311	+ else
		312	+ {
		313	+ LogDebug( "[OrmTable::updateRecord]", QString( "Skipping keyfield %1 ..." ).arg( fieldName ) );
		314	+ }
		315	+ }
		316	+
		317	+ // Process all changes.
		318	+ updateSuccess = this->submit();
		319	+ if( !updateSuccess )
		320	+ {
		321	+ LogError( "[OrmTable::updateRecord]",
		322	+ QString( "Record failed to update, Database gave error : %1").arg( this->lastError().text() ) );
		323	+ }
		324	+
		325	+ this->setFilter( "" );
		326	+ this->select();
		327	+ return updateSuccess;
		328	+ }
		329	+}
		330	+
		331	+bool OrmTable::batchUpdate( ORMData* dataObject, const QUuid& sourceId )
		332	+{
		333	+ // If MergedUpdate = true, we have to do an ex- and inclusive update.
		334	+ // (Inclusive meaning everyting that is mentioned, Exclusive : everything that is not in range..)
		335	+ // Similar to WHERE <field> NOT IN ( <VALUE1>, <Value2>, <VALUE..> )
		336	+
		337	+ QString fieldName;
		338	+
		339	+ // Get all fields to update, without the keyfield.
		340	+ // We only support a single field update at this moment.
		341	+ for( const auto& fn : dataObject->getFieldNames() )
		342	+ {
		343	+ if( fn != dataObject->getKeyField() )
		344	+ {
		345	+ fieldName = fn;
		346	+ break;
		347	+ }
		348	+ }
		349	+
		350	+ auto timeline = m_qhTimelines[sourceId];
		351	+ if (!timeline)
		352	+ {
		353	+ auto pTimeline = QSharedPointer<Timeline>::create();
		354	+ timeline.swap(pTimeline);
		355	+ m_qhTimelines[sourceId] = timeline;
		356	+ }
		357	+ OrmBatchChange obc(Timestamp(dataObject->timeStamp()), dataObject->getValue( fieldName ), OrmBatchChange::toSet(dataObject->getValue( dataObject->getKeyField() ).toList()));
		358	+ auto proposed = timeline->evaluate(obc, static_cast<int>(TableActions::actionMergeUpdate) == dataObject->getDefaultAction());
		359	+
		360	+ if (!proposed.valid())
		361	+ {
		362	+ LogInfo( "[OrmTable::batchUpdate]", "Proposed update will not be executed" );
		363	+ return false;
		364	+ }
		365	+ dataObject->setValue( dataObject->getKeyField(), OrmBatchChange::toList(proposed.changeSet()));
		366	+ QString strTable = dataObject->getContainerName();
		367	+ return m_db.associate(strTable, dataObject->getKeyField(), dataObject->getValue( dataObject->getKeyField() ).toList(), fieldName, dataObject->getValue( fieldName ));
		368	+}
		369	+
		370	+bool OrmTable::deCoupleRecords( ORMData* dataObject )
		371	+{
		372	+ QString fieldName;
		373	+
		374	+ // Get all fields to update, without the keyfield.
		375	+ // We only support a single field update at this moment.
		376	+ for( const auto& fn : dataObject->getFieldNames() )
		377	+ {
		378	+ if( fn != dataObject->getKeyField() )
		379	+ {
		380	+ fieldName = fn;
		381	+ break;
		382	+ }
		383	+ }
		384	+ QString strTable = dataObject->getContainerName();
		385	+ return m_db.disassociate(strTable, dataObject->getKeyField(), dataObject->getValue( dataObject->getKeyField() ).toList(), fieldName, dataObject->getValue( fieldName ));
		386	+}
		387	+
		388	+QList<OrmTableRow> OrmTable::readData( const QString& fieldName, const QString& filterExp )
		389	+{
		390	+ int columnIndex = this->fieldIndex( fieldName );
		391	+ QSortFilterProxyModel filterModel;
		392	+ filterModel.setSourceModel( this );
		393	+
		394	+ if( columnIndex > -1 )
		395	+ {
		396	+
		397	+ filterModel.setFilterKeyColumn( columnIndex );
		398	+ filterModel.setFilterRegExp( QRegExp( filterExp, Qt::CaseSensitive, QRegExp::Wildcard ) );
		399	+ }
		400	+
		401	+ if( filterModel.rowCount() > 0 )
		402	+ {
		403	+ // Looks like there was a result. Pack into a structure..
		404	+ int rows = filterModel.rowCount();
		405	+ int columns = filterModel.columnCount();
		406	+
		407	+ // For each row and column, iterate the data structure..
		408	+ for( int _rowCount = 0; _rowCount < rows; _rowCount++ )
		409	+ {
		410	+ qDebug() << "=____";
		411	+ for( int _colCount = 0; _colCount < columns; _colCount++ )
		412	+ {
		413	+ qDebug() << filterModel.headerData( _colCount, Qt::Horizontal, Qt::DisplayRole ) << " : "
		414	+ << filterModel.data( filterModel.index( _rowCount, _colCount ), Qt::DisplayRole );
		415	+ }
		416	+ }
		417	+ }
		418	+
		419	+ return QList<OrmTableRow>();
		420	+}
		421	+
		422	+QList<DbRelation *> OrmTable::getRelationsByTableName( const QString& _tableName )
		423	+{
		424	+ QList<DbRelation*> lstResult;
		425	+
		426	+ for( auto relName : m_qhRelations.keys() )
		427	+ {
		428	+ if( m_qhRelations.value( relName )->foreignTable() == _tableName )
		429	+ {
		430	+ lstResult.append( m_qhRelations.value( relName ) );
		431	+ }
		432	+ }
		433	+
		434	+ return lstResult;
		435	+}
		436	+
		437	+QSqlRecord OrmTable::buildSqlRecord( ORMData* tableObject )
		438	+{
		439	+ LogDebug( "[OrmTable::buildSqlRecord]", QString( "Building record with : %1 " ).arg( tableObject->asString() ) );
		440	+ QStringList fieldNames = tableObject->getFieldNames();
		441	+ QSqlRecord sqlRecord;
		442	+ for( const QString& fieldName : fieldNames )
		443	+ {
		444	+ if( fieldName != "container" )
		445	+ {
		446	+ QSqlField sqlField( fieldName, m_qhFieldTypes.value( fieldName ) );
		447	+ sqlField.setValue( ConversionUtils::convertToType( tableObject->getValue( fieldName ), // The value
		448	+ m_qhFieldTypes.value( fieldName ) ) ); // The Type
		449	+ sqlRecord.append( sqlField );
		450	+ }
		451	+ }
		452	+
		453	+ return sqlRecord;
		454	+}
		455	+
		456	+void OrmTable::setRelatedTable(const QString& _tableName, QSortFilterProxyModel* pTable)
		457	+{
		458	+ m_qhRelTables.insert( _tableName, pTable );
		459	+}
		460	+
		461	+QSortFilterProxyModel* OrmTable::getRelatedTable(const QString& _tableName) const
		462	+{
		463	+ return m_qhRelTables.value( _tableName );
		464	+}
		465	+
		466	+
		467	+void OrmTable::saveRelation( const QString& relationName, DbRelation* pRelation )
		468	+{
		469	+ LogDebug( "[OrmTable::saveRelation]", QString( "Saving Relation : %1" ).arg( relationName ) );
		470	+ m_qhRelations.insert( relationName, pRelation );
		471	+}
		472	+
		473	+DbRelation* OrmTable::getRelation( const QString& relationName ) const
		474	+{
		475	+ return m_qhRelations.value( relationName, nullptr );
		476	+}
		477	+
		478	+QStringList OrmTable::getRelationNames() const
		479	+{
		480	+ return QStringList( m_qhRelations.keys() );
		481	+}
		482	+
		483	+ORMData* OrmTable::solveRelations( const QSharedPointer<ORMRelData>& dataObject )
		484	+{
		485	+ // First we get the Maintable.... This will be our return object.
		486	+ ORMData* pMainTable = dataObject->getMainTableContainer();
		487	+ if( nullptr == pMainTable )
		488	+ {
		489	+ return nullptr;
		490	+ }
		491	+
		492	+ if( pMainTable->hasLists() )
		493	+ {
		494	+ LogWarning( "OrmTable::solveRelations", QString( "Maintable has Lists.... : %1" ).arg( pMainTable->asString() ) );
		495	+ }
		496	+
		497	+ QStringList constraintList = this->getRelationNames();
		498	+
		499	+ for( auto constraint : constraintList )
		500	+ {
		501	+ const DbRelation* l_relation = QPointer<DbRelation>( this->getRelation( constraint ) );
		502	+ QString foreignPrimKey;
		503	+ QString foreignFieldName;
		504	+ QVariant foreignFieldValue;
		505	+
		506	+ LogDebug("[OrmTable::solveRelations]", QString("Get related table %1").arg(l_relation->foreignTable()));
		507	+ ORMData* pTable = dataObject->getRelatedContainer( l_relation->foreignTable() );
		508	+ if( nullptr != pTable )
		509	+ {
		510	+ // We assume there is only 1 relation between two tables
		511	+ int numFields = pTable->getFieldCount();
		512	+ if( 0 == numFields )
		513	+ {
		514	+ LogWarning( "[OrmTable::solveRelations]", QString( "No relations found to table : %1 " ).arg( l_relation->foreignTable() ) );
		515	+ return nullptr;
		516	+ }
		517	+ else if( 1 == numFields )
		518	+ {
		519	+ foreignPrimKey = l_relation->foreignPrimKey();
		520	+ foreignFieldName = pTable->getFieldNames().first();
		521	+ // ===========================================================================================
		522	+ // L I S T O R S I N G L E V A L U E R E L A T I O N
		523	+ // ===========================================================================================
		524	+ foreignFieldValue = pTable->getValue( foreignFieldName );
		525	+ if( foreignFieldValue.isNull() )
		526	+ {
		527	+ // Some constraints are allowed to be absent. For now treat this constraint as such.
		528	+ // If it is needed afterall it will prevent the write in a later stage
		529	+ pMainTable->setValue( l_relation->indexColumn(), QVariant() );
		530	+ continue;
		531	+ }
		532	+
		533	+ // Looks like we have all data collected. Retrieve the Primary key value needed.
		534	+ // If foreignPrimKey is empty it will be retrieved from the database meta data.
		535	+ QVariant l_primKeyValue = m_db.getRelationKey( l_relation->foreignTable(), foreignFieldName, foreignFieldValue, foreignPrimKey );
		536	+ if( !l_primKeyValue.isNull() )
		537	+ {
		538	+ // We have a value of the IndexColumn. Complete the mainTable....
		539	+ pMainTable->setValue( l_relation->indexColumn(), l_primKeyValue );
		540	+ }
		541	+ else
		542	+ {
		543	+ LogError( "[OrmTable::solveRelations]", QString( "No primary key found for table : %1 " ).arg( l_relation->foreignTable() ) );
		544	+ return nullptr;
		545	+ }
		546	+ // ===========================================================================================
		547	+ }
		548	+ else
		549	+ {
		550	+ /// @todo : At this moment we don't handle multiple relations. Lotsplitting is requiring this, so it must be implemented as soon as
		551	+ /// the requirements are defined.
		552	+ LogError( "[OrmTable::solveRelations]", QString( "multiple relations found to table : %1 " ).arg( l_relation->foreignTable() ) );
		553	+ return nullptr;
		554	+ }
		555	+ }
		556	+ else
		557	+ {
		558	+ LogDebug( "[OrmTable::solveRelations]", QString( "Unresolved constraint %1. We assume all data is provided by the object.." ).arg( constraint ) );
		559	+ }
		560	+ }
		561	+
		562	+ return pMainTable;
		563	+}
		564	+
		565	+int OrmTable::tableFilter( ORMData* dataObject )
		566	+{
		567	+ int nResult = -1;
		568	+
		569	+ // Check for a valid pointer.
		570	+ if( nullptr == dataObject )
		571	+ {
		572	+ LogError( "[OrmTable::tableFilter]", QString( "No data structure given." ) );
		573	+ return 0;
		574	+ }
		575	+
		576	+ // Check if update is the default action
		577	+ if( static_cast<int>(TableActions::actionUpdate) != dataObject->getDefaultAction() )
		578	+ {
		579	+ LogWarning( "[OrmTable::tableFilter]", QString( "Update is not the default action for table : %1" ).arg( dataObject->getContainerName() ) );
		580	+ return 0;
		581	+ }
		582	+
		583	+ /// @todo : Create an AND / OR filter.
		584	+ // +----------------------------------+
		585	+ // \| Keyfield \| KeyValue \| TypeFilter \|
		586	+ // +----------+----------+------------+
		587	+ // \| = 1 \| = 1 \| equals \|
		588	+ // \| = 1 \| > 1 \| OR \| ( WHERE IN ( a, b, c, d...) )
		589	+ // \| > x \| > y \| AND \| ( x equals y)
		590	+ // \| <> KV \| <> KF \| INVALID \|
		591	+ // +----------+----------+------------+
		592	+ //
		593	+ // Check if there is a record that matches our criteria.
		594	+
		595	+ const auto keyFields = dataObject->getKeyFieldList();
		596	+
		597	+ for (const auto& field : keyFields)
		598	+ {
		599	+ if( this->fieldIndex(field) == -1 )
		600	+ {
		601	+ LogWarning( "[OrmTable::tableFilter]", QString( "No columnIndex found for : %1" ).arg(field) );
		602	+ return 0;
		603	+ }
		604	+ }
		605	+
		606	+ QString strFilter;
		607	+ const auto numberOfKeys = keyFields.length();
		608	+
		609	+ if (0 == numberOfKeys)
		610	+ {
		611	+ LogWarning( "[OrmTable::tableFilter]", QString( "No keyField given for table : %1" ).arg( dataObject->getContainerName() ) );
		612	+ return 0;
		613	+ }
		614	+ else if (1 == numberOfKeys)
		615	+ {
		616	+ const auto& keyField = *keyFields.begin();
		617	+
		618	+ if( dataObject->getValue( keyField ).type() == QVariant::List ) // OR
		619	+ {
		620	+ QList<QVariant> tmpList = dataObject->getValue( keyField ).toList();
		621	+ for( int lstCount = 0; lstCount < tmpList.count(); lstCount++ )
		622	+ {
		623	+ if( tmpList.at(lstCount).type() == QVariant::Int )
		624	+ {
		625	+ strFilter += keyField + "=" + tmpList.at( lstCount ).toString();
		626	+ }
		627	+ else
		628	+ {
		629	+ strFilter += "\"" + keyField + "\"='" + tmpList.at( lstCount ).toString().replace("{","").replace("}","") + "'";
		630	+ }
		631	+
		632	+ if( ( lstCount + 1 ) < tmpList.count() )
		633	+ {
		634	+ strFilter += " OR ";
		635	+ }
		636	+ }
		637	+ }
		638	+ else // equals
		639	+ {
		640	+ if( dataObject->getValue( keyField ).type() == QVariant::Int )
		641	+ {
		642	+ strFilter = "\"" + keyField + "\"="+ dataObject->getValue( keyField ).toString();
		643	+ }
		644	+ else
		645	+ {
		646	+ strFilter = "\"" + keyField + "\"='" + dataObject->getValue( keyField ).toString().replace("{","").replace("}","") + "'";
		647	+ }
		648	+ }
		649	+ }
		650	+ else // numberOfKeys > 1, AND
		651	+ {
		652	+ // =========================================================
		653	+ // @todo: Setup a multiple fields filter. For now it is just a multiple values value filter.
		654	+
		655	+ auto iter = keyFields.constBegin();
		656	+ while (keyFields.constEnd() != iter)
		657	+ {
		658	+ if( dataObject->getValue( *iter ).type() == QVariant::Int )
		659	+ {
		660	+ strFilter += "\"" + iter + "\"=" + dataObject->getValue( iter ).toString();
		661	+ }
		662	+ else
		663	+ {
		664	+ strFilter += "\"" + iter + "\"='" + dataObject->getValue( iter ).toString().replace("{","").replace("}","") + "'";
		665	+ }
		666	+
		667	+ ++iter;
		668	+
		669	+ if( keyFields.end() != iter )
		670	+ {
		671	+ strFilter += " AND ";
		672	+ }
		673	+ }
		674	+ }
		675	+
		676	+ this->setFilter( strFilter );
		677	+ LogDebug( "[OrmTable::tableFilter]", QString( "Filter : %1" ).arg( this->filter() ) );
		678	+ if( this->select() )
		679	+ {
		680	+ nResult = this->rowCount();
		681	+ }
		682	+ else
		683	+ {
		684	+ LogError( "[OrmTable::tableFilter]", QString( "There was a problem executing the query : %1" ).arg( this->selectStatement() ) );
		685	+ }
		686	+ // =========================================================
		687	+ return nResult;
		688	+}
		689	+
		690	+int OrmTable::resetFilter()
		691	+{
		692	+ this->setFilter( "" );
		693	+ this->select();
		694	+ return rowCount();
		695	+}
		696	+
		697	+bool OrmTable::isPackageValid( ORMData* dataObject )
		698	+{
		699	+ if( nullptr == dataObject )
		700	+ {
		701	+ LogError( "[OrmTable::isPackageValid]", "No ORMData dataobject passed." );
		702	+ return false;
		703	+ }
		704	+
		705	+ // Determine the field indices for the proxy filter
		706	+ auto keyFields = dataObject->getKeyFieldList();
		707	+ QList<qint32> fieldIndices;
		708	+ auto iter = keyFields.begin();
		709	+ while (keyFields.end() != iter)
		710	+ {
		711	+ auto idx = this->fieldIndex(*iter);
		712	+ if (idx > -1)
		713	+ {
		714	+ fieldIndices.push_back(idx);
		715	+ ++iter;
		716	+ }
		717	+ else
		718	+ {
		719	+ LogWarning("[OrmTable::isPackageValid]", QString("Keyfield \"%1\" is unknown. Not using it in filter.").arg(*iter));
		720	+ iter = keyFields.erase(iter);
		721	+ }
		722	+ }
		723	+
		724	+ // Create the filter model and set its filter criteria
		725	+ MultiSortFilterProxyModel oModelFilter;
		726	+ oModelFilter.setFilterKeyColumns( fieldIndices );
		727	+
		728	+ // Build the filter expression.
		729	+ for (qint32 i = 0; i < fieldIndices.size(); ++i)
		730	+ {
		731	+ oModelFilter.setFilterFixedString( fieldIndices[i], QString( "%1" ).arg( dataObject->getValue( keyFields[i] ).toString() ) );
		732	+ }
		733	+
		734	+ // Attach filter to this table model.
		735	+ oModelFilter.setSourceModel( this );
		736	+
		737	+ // If the number of record = 1, we seem to have found our record.
		738	+ if( 0 == oModelFilter.rowCount() )
		739	+ {
		740	+ // Seems like we are good to go.
		741	+ // This is a first timer...
		742	+ LogDebug("[OrmTable::isPackageValid]", "No record found");
		743	+ return true;
		744	+ }
		745	+ else if ( 1 == oModelFilter.rowCount() )
		746	+ {
		747	+ QModelIndex modIndex = oModelFilter.index( 0, this->fieldIndex( m_recTrackField ) );
		748	+ unsigned long long tmp_timestamp = oModelFilter.data( modIndex, Qt::DisplayRole ).toULongLong();
		749	+
		750	+ if( dataObject->timeStamp() > tmp_timestamp )
		751	+ {
		752	+ return true;
		753	+ }
		754	+ }
		755	+ else
		756	+ {
		757	+ LogError( "[OrmTable::isPackageValid]", QString( "Multiple records found (%1) for %2 with value %3" )
		758	+ .arg( oModelFilter.rowCount() )
		759	+ .arg( dataObject->getKeyField() )
		760	+ .arg( dataObject->getValue( dataObject->getKeyField() ).toString() ) );
		761	+ }
		762	+ return false;
		763	+}
		764	+
		765	+bool OrmTable::commit()
		766	+{
		767	+ if( m_db.supportTransactions() )
		768	+ {
		769	+ if( m_db.transactionCommit() )
		770	+ {
		771	+ return true;
		772	+ }
		773	+ else
		774	+ {
		775	+ LogWarning( "[OrmTable::commit]", QString( "Transaction failed to commit with error : %1" )
		776	+ .arg( m_db.getDatabase().driver()->lastError().text() ) );
		777	+ }
		778	+ }
		779	+ else
		780	+ {
		781	+ if( m_db.getDatabase().driver()->lastError().driverText().isEmpty() )
		782	+ {
		783	+ return true;
		784	+ }
		785	+ else
		786	+ {
		787	+ LogDebug( "[OrmTable::commit]", QString( "Transaction not supported but last query failed with error : %1" )
		788	+ .arg( m_db.getDatabase().driver()->lastError().driverText() ) );
		789	+ }
		790	+ }
		791	+ return false;
		792	+}

src/ormtable.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtable.h
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+#ifndef OSDEV_COMPONENTS_ORMTABLE_H
		23	+#define OSDEV_COMPONENTS_ORMTABLE_H
		24	+
		25	+#include <QObject>
		26	+#include <QStringList>
		27	+#include <QSqlRelationalTableModel>
		28	+#include <QSortFilterProxyModel>
		29	+#include <QSqlDatabase>
		30	+#include <QSqlRecord>
		31	+#include <QHash>
		32	+
		33	+#include "dbconnector.h"
		34	+#include "ormreldata.h"
		35	+#include "ormtablerow.h"
		36	+#include "dbrelation.h"
		37	+#include "conversionutils.h"
		38	+#include "timeline.h"
		39	+
		40	+namespace osdev {
		41	+namespace components {
		42	+
		43	+/*!
		44	+ * \brief This class is used as a TransActionsscopeGuard
		45	+ * It takes a database connection at its constructor
		46	+ * and calls the rollBack method in its destructor.
		47	+ */
		48	+class OrmTransGuard
		49	+{
		50	+public:
		51	+ OrmTransGuard()
		52	+ : m_db(nullptr)
		53	+ {
		54	+ }
		55	+
		56	+ explicit OrmTransGuard( DbConnector& _db )
		57	+ : m_db( &_db )
		58	+ {
		59	+ }
		60	+
		61	+ ~OrmTransGuard()
		62	+ {
		63	+ if (nullptr != m_db)
		64	+ {
		65	+ m_db->transactionRollback();
		66	+ }
		67	+ }
		68	+
		69	+ OrmTransGuard(const OrmTransGuard&) = delete;
		70	+ OrmTransGuard& operator=(const OrmTransGuard&) = delete;
		71	+
		72	+ OrmTransGuard(OrmTransGuard&& rhs)
		73	+ : m_db(std::move(rhs.m_db))
		74	+ {
		75	+ rhs.m_db = nullptr;
		76	+ }
		77	+
		78	+ OrmTransGuard& operator=(OrmTransGuard&& rhs)
		79	+ {
		80	+ if (this == &rhs)
		81	+ {
		82	+ return *this;
		83	+ }
		84	+
		85	+ if (nullptr != m_db)
		86	+ {
		87	+ m_db->transactionRollback();
		88	+ }
		89	+ m_db = std::move(rhs.m_db);
		90	+ rhs.m_db = nullptr;
		91	+ return *this;
		92	+ }
		93	+
		94	+private:
		95	+ DbConnector* m_db;
		96	+};
		97	+
		98	+/*!
		99	+ * \brief The OrmTable represents a database table. Depending
		100	+ * on the EditStrategy, it updates the database by each
		101	+ * inserted record or after all records are inserted.
		102	+ * \note Internally setTable is used. Please do not use setQuery
		103	+ * also because that will invalidate the OrmTable meta data.
		104	+ */
		105	+class OrmTable : public QSqlRelationalTableModel
		106	+{
		107	+ Q_OBJECT
		108	+
		109	+public:
		110	+ /*!
		111	+ * \brief Default constructor.
		112	+ * \param parent The parent object as a QObject pointer
		113	+ * \param db The database layer we're connected through.
		114	+ */
		115	+ explicit OrmTable(const DbConnector& db, QObject *parent = nullptr );
		116	+
		117	+ // Deleted copy- and move constructors
		118	+ OrmTable( const OrmTable& ) = delete;
		119	+ OrmTable( const OrmTable&& ) = delete;
		120	+ OrmTable& operator=( const OrmTable& ) = delete;
		121	+ OrmTable& operator=( const OrmTable&& ) = delete;
		122	+
		123	+ /// \brief Destructor
		124	+ virtual ~OrmTable();
		125	+
		126	+ /*!
		127	+ * \brief Sets the tablename, this model represents.
		128	+ * \param table The name of the table.
		129	+ */
		130	+ void setTable( const QString& table );
		131	+
		132	+ /*!
		133	+ * \brief Insert a single QSqlRecord into the model.
		134	+ * \param row Inserts the record at position row.
		135	+ * If row is negative, the record will be appended to the end.
		136	+ * \param record Record to insert
		137	+ * \return true if the record could be inserted, otherwise false.
		138	+ */
		139	+ bool insertRecord( int row, const QSqlRecord &record );
		140	+
		141	+ /*!
		142	+ * \brief Insert multiple QSqlRecords into the model.
		143	+ * \param row Inserts the records at position row.
		144	+ * If row is negative, the records will be appended to the end.
		145	+ * calls insertRecord internally.
		146	+ * \param records Records to insert
		147	+ * \return true if the record could be inserted, otherwise false.
		148	+ */
		149	+ bool insertRecords(int row, const QList<QSqlRecord>& records );
		150	+
		151	+ /*!
		152	+ * \brief writes the data given in the dataobject to the table and to the database.
		153	+ * \param dataObject - Contains all relational data.
		154	+ */
		155	+ void writeData( const QSharedPointer<ORMRelData>& dataObject );
		156	+
		157	+ /*!
		158	+ * \brief writes the values to a given record, identified by the fieldname in "KeyField".
		159	+ * \param dataObject - Contains "flat" data
		160	+ * \return True if successful, false if not.
		161	+ */
		162	+ bool updateRecord( ORMData* dataObject );
		163	+
		164	+ /*!
		165	+ * \brief This method is for convenience only. It will retrieve (a set of) records, based on the criteria given.
		166	+ * \param fieldName - The fieldname we like to filter on
		167	+ * \param filterExp - The filter expression
		168	+ * \return A QList of SQLRecords containing the results.
		169	+ * The list will be empty if no records were found or the table is empty.
		170	+ */
		171	+ QList<OrmTableRow> readData( const QString& fieldName = QString(), const QString& filterExp = QString() );
		172	+
		173	+
		174	+ /*!
		175	+ * \brief Returns the number of relations added to this table.
		176	+ * \return The number of relations. 0 if none.
		177	+ */
		178	+ int numberOfRelations() const { return m_qhRelations.count(); }
		179	+
		180	+ /*!
		181	+ * \brief setRelatedTable
		182	+ * \param tableName The name of the related table.
		183	+ * \todo Verify pointer ownership
		184	+ * \param pTable Owning pointer to the Table. Ownership is transferred to this instance.
		185	+ */
		186	+ void setRelatedTable( const QString& tableName, QSortFilterProxyModel* pTable );
		187	+
		188	+ /*!
		189	+ * \brief Gets the RelatedTable for the specified table name.
		190	+ * \param tableName The name of the table for which to get the relation.
		191	+ * \return The relation to the table with the specified table name.
		192	+ */
		193	+ QSortFilterProxyModel* getRelatedTable( const QString& tableName ) const;
		194	+
		195	+ /*!
		196	+ * \brief Store the relation to another table, stored by its unique name.
		197	+ * ORMTable is owner of the relation pointer.
		198	+ * \param relationName - the Name of the relation as known by the database.
		199	+ */
		200	+ void saveRelation( const QString& relationName, DbRelation* pRelation );
		201	+
		202	+ /*!
		203	+ * \brief Get the relationstructure
		204	+ * \param relationName The name of the relation to get.
		205	+ * \return The pointer to the datastructure. NULL if none exist.
		206	+ */
		207	+ DbRelation* getRelation( const QString& relationName ) const;
		208	+
		209	+ /*!
		210	+ * \brief Get all registered constraintnames by their true name.
		211	+ * \return The list of all relation by their contraint names. If no relations exist, the list will be empty.
		212	+ */
		213	+ QStringList getRelationNames() const;
		214	+
		215	+ /*!
		216	+ * \brief Gets the attached relation based on a given tablename.
		217	+ * \param tableName - The tablename we want the relation on.
		218	+ * \return The relation we're searching for. isValid is true if there is a relation, false if not.
		219	+ */
		220	+ QList<DbRelation*> getRelationsByTableName( const QString& tableName );
		221	+
		222	+ /*!
		223	+ * \brief This method will solve any relations in the structure.
		224	+ * \param dataObject - The ORMRelData object describing the data
		225	+ * \return The ORMData object with all solved references, if there were any.
		226	+ * If the main container can't be retrieved, it will return a nullptr. Check for validity.
		227	+ */
		228	+ ORMData* solveRelations( const QSharedPointer<ORMRelData>& dataObject );
		229	+
		230	+ /*!
		231	+ * \brief Do a "batched" update. The dataobject contains lists which represents different records.
		232	+ * \param dataObject - The "maintable" object after resolving the relations.
		233	+ * It is the responsibility of this TableObject to delete this object if successful,
		234	+ * else it will be rejected and ownership will be transferred to the next subsystem.
		235	+ * before calling this method, a transaction should be started on the referenced database
		236	+ * connection. If this method ( and possible following statements like deCoupleRecords )
		237	+ * the transaction should be committed.
		238	+ * \param sourceId The source from which the dataObject originates.
		239	+ * \return True if the complete update was successful. False if not and should result in a rejected
		240	+ * transaction. ( See signalRejectedData() ) Rejecting should be done by the calling method.
		241	+ */
		242	+ bool batchUpdate( ORMData* dataObject, const QUuid& sourceId );
		243	+
		244	+ /*!
		245	+ * \brief Decouple records from their previous value (Normally a foreign key relation).
		246	+ * This method will fail if a field in the database is not-nullable or the number
		247	+ * of fields is larger than 2 (1 searchField and 1 updateable field.
		248	+ * \param dataObject - The dataobject containing all the information needed to update the record(s).
		249	+ * It is the responsibility of this TableObject to delete this object if successful,
		250	+ * else it will be rejected and ownership will be transferred to the next subsystem.
		251	+ * before calling this method, a transaction should be started on the referenced database
		252	+ * connection. If this method ( and possible previous statements like batchUpdate() )
		253	+ * the transaction should be committed.
		254	+ * \return true if successful. false if not.
		255	+ */
		256	+ bool deCoupleRecords( ORMData* dataObject );
		257	+
		258	+ /*!
		259	+ * \brief Get the name of the field that will track the mutation date / time in uSecs since EPOCH.
		260	+ * \return The name of the field. Empty if no field was configured.
		261	+ */
		262	+ QString trackField() { return m_recTrackField; }
		263	+
		264	+ /*!
		265	+ * \brief Get the name of the field that will track the mutation date / time in uSecs since EPOCH.
		266	+ * \param _recTrackFieldName - The name of the field, coming from the configuration.
		267	+ */
		268	+ void setTrackField( const QString& _recTrackFieldName ) { m_recTrackField = _recTrackFieldName; }
		269	+
		270	+
		271	+signals:
		272	+ /*!
		273	+ * \brief Signal for RejectedData.
		274	+ * \param dataContainer The data container for this signal.
		275	+ */
		276	+ void signalRejectedData( const QSharedPointer<ORMRelData>& dataContainer );
		277	+
		278	+private:
		279	+
		280	+ /*!
		281	+ * \brief Translates an ORMData into an QSqlRecord
		282	+ * \param tableObject - The tableObject we like to translate into an sql-record to store.
		283	+ * \return The QSqlRecord object representing an entry. If the creation of the record fails,
		284	+ * the result will be an empty SqlRecord structure.
		285	+ */
		286	+ QSqlRecord buildSqlRecord( ORMData* tableObject );
		287	+
		288	+ /*!
		289	+ * \brief Builds a query and filters the table data. Data isn't removed, but a resultset is shown.
		290	+ *
		291	+ * \param dataObject - The dataobject of this particular table as extracted from ORMRelData. Based on the
		292	+ * keyField(s) and values, the filter is set. ( See also resetFilter() )
		293	+ * \return The number of resulting records that match the criteria. If the filter fails, the result will be -1.
		294	+ */
		295	+ int tableFilter( ORMData* dataObject );
		296	+
		297	+ /*!
		298	+ * \brief Checks if the ORMData package is valid against the record it tries to update. Each table should have a
		299	+ * field of type INT which contains the timestamp since epoch. Before updating a record, it should check if the timestamp
		300	+ * of the package is actually newer than the timestamp of that record. If the package is newer ( a.k.a. Package timestamp > timestamp_record )
		301	+ * it is valid to update the record with its values, including the timestamp. This will prevent the situation where records will be overwritten
		302	+ * with "old" data. This method works together with the internal variable 'm_recTrackField'. Before calling this method, we have to check if this
		303	+ * variable isn't empty. If so, we don't keep track of record changes in a timeline and we can update the records anyway.
		304	+ *
		305	+ * \param dataObject - The ORMData object containing a complete transaction.
		306	+ * Does not have to be resolved by relations yet, this will be done after the validity check.
		307	+ *
		308	+ * \return True if the record can be updated, False if the package is older than the actual record.
		309	+ */
		310	+ bool isPackageValid( ORMData* dataObject );
		311	+
		312	+ /*!
		313	+ * \brief resets the filter, allowing the table to show all records. ( See also tableFilter() )
		314	+ * \return The number of records show by the table.
		315	+ */
		316	+ int resetFilter();
		317	+
		318	+ /*!
		319	+ * \brief Commit a database transaction if one is in progress.
		320	+ * \note If the driver does not support transactions this method will look at the last driver error and return false if it contains a message.
		321	+ * \return True if commit succeeds or if there was no transaction in progress, false if commit fails.
		322	+ */
		323	+ bool commit();
		324	+
		325	+ QString m_className; ///< Class name for logging purposes
		326	+ QString m_recTrackField; ///< Name of the field, which keep tracks of changes on each record. If Empty, we don't track.
		327	+ DbConnector m_db; ///< Database layer we're connected through. We need the reference to access its helper methods.
		328	+ QHash<QString, QSortFilterProxyModel*> m_qhRelTables; ///< Filtered view on a related table.
		329	+ QHash<QString, DbRelation*> m_qhRelations; ///< The actual relation Meta information stored for reference.
		330	+ QHash<QString, QVariant::Type> m_qhFieldTypes; ///< The internal storage for all fieldtypes by their fieldname.
		331	+ QHash<QUuid, QSharedPointer<Timeline>> m_qhTimelines; ///< Timelines used for the batch update
		332	+};
		333	+
		334	+} // End namespace components
		335	+} // End namespace osdev
		336	+
		337	+#endif /* OSDEV_COMPONENTS_ORMTABLE_H */

src/ormtablerow.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtablerow.cpp
		1	+#include "ormtablerow.h"
		2	+
		3	+using namespace osdev::components;
		4	+
		5	+OrmTableRow::OrmTableRow()
		6	+ : m_stoData()
		7	+{
		8	+
		9	+}
		10	+
		11	+OrmTableRow::~OrmTableRow()
		12	+{
		13	+ m_stoData.clear();
		14	+}
		15	+
		16	+void OrmTableRow::setField( QVariant vData, int column )
		17	+{
		18	+ if( -1 == column \|\| column >= m_stoData.count() )
		19	+ {
		20	+ m_stoData.append( vData );
		21	+ }
		22	+ else if( -1 < column && column < m_stoData.count() )
		23	+ {
		24	+ m_stoData.replace( column, vData );
		25	+ }
		26	+}
		27	+
		28	+QVariant OrmTableRow::getField( int column )
		29	+{
		30	+ if( -1 < column && column < m_stoData.count() )
		31	+ {
		32	+ return m_stoData.at( column );
		33	+ }
		34	+ return QVariant();
		35	+}
		36	+
		37	+void OrmTableRow::setFields( QList<QVariant> values )
		38	+{
		39	+ // Replace the entire internal structure with the new list.
		40	+ m_stoData.clear();
		41	+ for( const QVariant& value : values )
		42	+ {
		43	+ m_stoData.append( value );
		44	+ }
		45	+}

src/ormtablerow.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtablerow.h
		1	+#ifndef OSDEV_COMPONENTS_ORMTABLEROW_H
		2	+#define OSDEV_COMPONENTS_ORMTABLEROW_H
		3	+
		4	+#include <QVariant>
		5	+#include <QList>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+
		10	+/*!
		11	+ * \brief This class represents a single record, completely decoupled.
		12	+ * No fieldnames and no constraints.
		13	+ */
		14	+class OrmTableRow
		15	+{
		16	+public:
		17	+ OrmTableRow();
		18	+ virtual ~OrmTableRow();
		19	+
		20	+ void setField( QVariant vData, int column = -1 );
		21	+ QVariant getField( int column );
		22	+
		23	+ int getNumFields();
		24	+ void setFields( QList<QVariant> values );
		25	+
		26	+private:
		27	+ QList<QVariant> m_stoData;
		28	+};
		29	+
		30	+} /* End namespace components */
		31	+} /* End namespace osdev */
		32	+
		33	+#endif /* OSDEV_COMPONENTS_ORMTABLEROW_H */

src/ormthread.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormthread.cpp
		1	+#include "ormthread.h"
		2	+#include "ormhandler.h"
		3	+#include "log.h"
		4	+
		5	+using namespace osdev::components;
		6	+
		7	+ORMThread::ORMThread()
		8	+{
		9	+}
		10	+
		11	+ORMThread::~ORMThread()
		12	+{
		13	+}
		14	+
		15	+void ORMThread::run()
		16	+{
		17	+ OrmHandler *p_OrmHandler = new OrmHandler();
		18	+
		19	+ // Connect incoming data
		20	+ connect( this, &ORMThread::signalSendData, p_OrmHandler, &OrmHandler::receiveData );
		21	+ // Cascade connect the rejectedData
		22	+ connect( p_OrmHandler, &OrmHandler::signalRejectedData, this, &ORMThread::signalRejectedData );
		23	+
		24	+ p_OrmHandler->start();
		25	+
		26	+ this->exec();
		27	+}
		28	+
		29	+void ORMThread::dataToThread( const QSharedPointer<ORMRelData>& data )
		30	+{
		31	+ QCoreApplication::processEvents();
		32	+ LogDebug( "[ORMThread::dataToThread]", QString( "Data received for container : %1" )
		33	+ .arg( data->getMainTableName() ) );
		34	+ LogDebug( "[ORMThread::dataToThread]", data->asString() );
		35	+
		36	+ emit signalSendData( data );
		37	+ QCoreApplication::processEvents();
		38	+}

src/ormthread.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormthread.h
		1	+#ifndef OSDEV_COMPONENTS_ORMTHREAD_H
		2	+#define OSDEV_COMPONENTS_ORMTHREAD_H
		3	+
		4	+#include <QThread>
		5	+#include <QSharedPointer>
		6	+
		7	+#include "ormreldata.h"
		8	+
		9	+/* ______________________________________
		10	+ * / Good day to deal with people in high \
		11	+ * \| places; particularly lonely \|
		12	+ * \ stewardesses. /
		13	+ * --------------------------------------
		14	+ * \
		15	+ * \
		16	+ * .--.
		17	+ * \|o_o \|
		18	+ * \|:_/ \|
		19	+ * // \ \
		20	+ * (\| \| )
		21	+ * /'\_ _/`\
		22	+ * \___)=(___/
		23	+ //!
		24	+ * \brief This class manages the thread, the ORM layer will be started in.
		25	+ * Derived from QThread it isn't the thread itself but implements the
		26	+ * 'run()' method that'll start the thread. (QThread isn't meant to be
		27	+ * instantiated. It has to be derived.. :) )
		28	+ *
		29	+ * And sometimes it can be a Stewardess. That's polymorphism for yah!
		30	+ */
		31	+namespace osdev {
		32	+namespace components {
		33	+
		34	+class ORMThread : public QThread
		35	+{
		36	+ Q_OBJECT
		37	+
		38	+public:
		39	+ ORMThread();
		40	+
		41	+ // Deleted copy-constructor
		42	+ ORMThread( const ORMThread& ) = delete;
		43	+ ORMThread( const ORMThread&& ) = delete;
		44	+ ORMThread& operator=( const ORMThread& ) = delete;
		45	+ ORMThread& operator=( const ORMThread&& ) = delete;
		46	+
		47	+ /*!
		48	+ * \brief Destructor
		49	+ */
		50	+ virtual ~ORMThread();
		51	+
		52	+ /*!
		53	+ * \brief Override from QThread. This will actually create and start the thread.
		54	+ * Objects used here are "moved" to the new thread and run
		55	+ */
		56	+ void run() override;
		57	+
		58	+ /*!
		59	+ * \brief Send the data to the intended thread.
		60	+ * \param data Data coming from the plugin. Ownership is moved to the thread and that
		61	+ * specific thread is responsible for cleaning up.
		62	+ */
		63	+ void dataToThread( const QSharedPointer<ORMRelData>& data );
		64	+
		65	+signals:
		66	+ /*!
		67	+ * \brief Used to send the datastructure to the thread.
		68	+ * \param data Data coming from the plugin.
		69	+ */
		70	+ void signalSendData( const QSharedPointer<ORMRelData>& data );
		71	+
		72	+ /*!
		73	+ * \brief If the thread is unable to process the data that was sent, it will "reject" this.
		74	+ * Normally it would then be send to a subsystem, capable of storing the data and
		75	+ * resend it for re-processing.
		76	+ * \param data Data originally comming from the plugin (it can be enriched along the way).
		77	+ */
		78	+ void signalRejectedData( const QSharedPointer<ORMRelData>& data );
		79	+
		80	+};
		81	+
		82	+
		83	+} /* End namespace components */
		84	+} /* End namespace osdev */
		85	+
		86	+#endif /* OSDEV_COMPONENTS_ORMTHREAD_H */

src/ormtransqueue.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtransqueue.cpp
		1	+#include "ormtransqueue.h"
		2	+
		3	+#include <QCoreApplication>
		4	+#include "log.h"
		5	+
		6	+namespace osdev {
		7	+namespace caelus {
		8	+
		9	+OrmTransQueue::OrmTransQueue( QObject *_parent )
		10	+ : QObject(_parent)
		11	+ , m_pQueueTimer( nullptr )
		12	+ , m_pQueueMutex( nullptr )
		13	+ , m_ormQueue()
		14	+{
		15	+ m_pQueueMutex = new QMutex( QMutex::NonRecursive );
		16	+ setTimeOut( 1000 );
		17	+}
		18	+
		19	+void OrmTransQueue::setTimeOut( int mseconds )
		20	+{
		21	+ if( nullptr == m_pQueueTimer )
		22	+ {
		23	+ m_pQueueTimer = new QTimer( this );
		24	+ m_pQueueTimer->setSingleShot( false );
		25	+
		26	+ // Connect signal / slot..
		27	+ connect( m_pQueueTimer, SIGNAL( timeout() ),
		28	+ this, SLOT( slotProcessQueue() ), Qt::QueuedConnection );
		29	+ }
		30	+
		31	+ // Set the interval in milliseconds and start.
		32	+ m_pQueueTimer->setInterval( mseconds );
		33	+}
		34	+
		35	+bool OrmTransQueue::processing() const
		36	+{
		37	+ return m_pQueueTimer->isActive();
		38	+}
		39	+
		40	+void OrmTransQueue::startProcessing( bool force )
		41	+{
		42	+ if( force )
		43	+ {
		44	+ m_pQueueTimer->stop();
		45	+ this->slotProcessQueue();
		46	+ }
		47	+ else
		48	+ {
		49	+ if( !m_pQueueTimer->isActive() )
		50	+ {
		51	+ m_pQueueTimer->start();
		52	+ }
		53	+ }
		54	+}
		55	+
		56	+void OrmTransQueue::stopProcessing( bool force )
		57	+{
		58	+ if( force && !m_pQueueTimer->isActive() )
		59	+ {
		60	+ m_pQueueTimer->stop();
		61	+ }
		62	+}
		63	+
		64	+bool OrmTransQueue::setTransaction( ORMRelData *pData )
		65	+{
		66	+ QMutexLocker mutLock( m_pQueueMutex ); // << Later on we should do a conditional wait
		67	+ LogDebug( "[OrmTransQueue::setTransaction]", "Adding transaction to the transaction queue : ");
		68	+ m_ormQueue.enqueue( pData );
		69	+ LogDebug("[OrmTransQueue::setTransaction]", QString("Number of transactions in the queue : %1").arg( m_ormQueue.size() ) );
		70	+ this->startProcessing();
		71	+
		72	+ return true; // << Rethink about it..
		73	+}
		74	+
		75	+void OrmTransQueue::slotProcessQueue()
		76	+{
		77	+ m_pQueueTimer->stop();
		78	+ LogInfo( "[OrmTransQueue::slotProcessQueue]", "Start processing the transaction queue." );
		79	+ if( m_pQueueMutex->tryLock() )
		80	+ {
		81	+ LogDebug( "[OrmTransQueue::slotProcessQueue]", "!!!!!!!!!!!!!!!!!!!!! Lock Acquired !!!!!!!!!!!!!!!" );
		82	+ if( !m_ormQueue.isEmpty() )
		83	+ {
		84	+ LogInfo( "[OrmTransQueue::slotProcessQueue]", QString( "{ Before Emit } Number of transactions in the queue : %1 ").arg( m_ormQueue.size() ) );
		85	+ ORMRelData *pData = m_ormQueue.dequeue();
		86	+ Q_UNUSED( pData );
		87	+ LogDebug( "[OrmTransQueue::slotProcessQueue]", QString("{ Before Emit, after dequeue} Number of transactions in the queue : %1 ").arg( m_ormQueue.size() ) );
		88	+ // emit signalProcessData( pData );
		89	+ LogDebug( "[OrmTransQueue::slotProcessQueue]", QString("{ After Emit, after dequeue} Number of transactions in the queue : %1 ").arg( m_ormQueue.size() ) );
		90	+ QCoreApplication::processEvents();
		91	+ }
		92	+ m_pQueueMutex->unlock();
		93	+ LogDebug( "[OrmTransQueue::slotProcessQueue]", "!!!!!!!!!!!!!!!!!!!!! Lock Freed !!!!!!!!!!!!!!!" );
		94	+ }
		95	+ else
		96	+ {
		97	+ LogDebug( "[OrmTransQueue::slotProcessQueue]", "!!!!!!!!!!!!!!!!!!!!! No Lock !!!!!!!!!!!!!!!" );
		98	+ }
		99	+
		100	+ LogInfo( "[OrmTransQueue::slotProcessQueue]", "Done processing the transaction queue." );
		101	+ if( m_ormQueue.size() > 0 )
		102	+ {
		103	+ m_pQueueTimer->start();
		104	+ }
		105	+}
		106	+
		107	+
		108	+
		109	+} /* End namespace caelus */
		110	+} /* End namespace osdev */

src/ormtransqueue.h 0 → 100644

View file @5251bf3

		1	+++ a/src/ormtransqueue.h
		1	+#ifndef OSDEV_CAELUS_ORMTRANSQUEUE_H
		2	+#define OSDEV_CAELUS_ORMTRANSQUEUE_H
		3	+
		4	+// Qt
		5	+#include <QObject>
		6	+#include <QTimer>
		7	+#include <QMutex>
		8	+#include <QMutexLocker>
		9	+#include <QQueue>
		10	+
		11	+// Local
		12	+#include "ormreldata.h"
		13	+
		14	+namespace osdev {
		15	+namespace caelus {
		16	+
		17	+class OrmTransQueue : public QObject
		18	+{
		19	+ Q_OBJECT
		20	+
		21	+public:
		22	+ explicit OrmTransQueue( QObject *_parent = 0 );
		23	+
		24	+ // Copy constructors.
		25	+
		26	+ // Deleted copy- and move constructors
		27	+ OrmTransQueue( const OrmTransQueue& ) = delete;
		28	+ OrmTransQueue( const OrmTransQueue&& ) = delete;
		29	+ OrmTransQueue& operator=( const OrmTransQueue& ) = delete;
		30	+ OrmTransQueue& operator=( const OrmTransQueue&& ) = delete;
		31	+
		32	+ // Timer control.
		33	+ /*!
		34	+ * \brief setTimeOut
		35	+ * \param msec
		36	+ */
		37	+ void setTimeOut(int mseconds = 1 );
		38	+
		39	+ // Queue control
		40	+ /*!
		41	+ * \brief Inserts a ORMReldata objectpointer into the queue.
		42	+ * \param pData - the (valid) pointer of the ORMRelData structure we want to queue for later processing
		43	+ * \return True if transaction was saved to the queue successfully, false if not.
		44	+ */
		45	+ bool setTransaction( ORMRelData *pData );
		46	+
		47	+ bool processing() const;
		48	+
		49	+ void startProcessing( bool force = false );
		50	+
		51	+ void stopProcessing( bool force = false );
		52	+
		53	+ /*!
		54	+ * \brief Returns the number of transactions stored in the queue.
		55	+ * \return The number of transactions, or 0 if empty.
		56	+ */
		57	+ int transactions_count() { return m_ormQueue.size(); }
		58	+
		59	+signals:
		60	+ void signalProcessData( ORMRelData *pData );
		61	+
		62	+private:
		63	+ QTimer *m_pQueueTimer; ///< Timer controlling the processing of the queue.
		64	+ QMutex *m_pQueueMutex; ///< Mutex to prevent race conditions.
		65	+ QQueue<ORMRelData*> m_ormQueue; ///< The actual FIFO taking a ORMRelData pointer as input.
		66	+
		67	+private slots:
		68	+ /*!
		69	+ * \brief slotProcessQueue
		70	+ */
		71	+ void slotProcessQueue();
		72	+
		73	+
		74	+};
		75	+
		76	+} /* End namespace caelus */
		77	+} /* End namespace osdev */
		78	+
		79	+#endif /* OSDEV_CAELUS_ORMTRANSQUEUE_H */

src/timeline.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/timeline.cpp
		1	+#include "timeline.h"
		2	+
		3	+#include "log.h"
		4	+
		5	+using namespace osdev::components;
		6	+
		7	+Timeline::Timeline()
		8	+ : m_timeline(10)
		9	+ , m_proposedChange()
		10	+{
		11	+}
		12	+
		13	+const OrmBatchChange& Timeline::evaluate(const OrmBatchChange& desiredChange, bool exclusiveUpdate)
		14	+{
		15	+ m_proposedChange = OrmBatchChange {};
		16	+ if (m_timeline.full() && desiredChange < m_timeline.front())
		17	+ {
		18	+ LogWarning("[Timeline::evaluate]", QString("Incoming change (%1) is older then the oldest registered change (%2).").arg(desiredChange.timestamp().toString()).arg(m_timeline.front().timestamp().toString()));
		19	+ return m_proposedChange; // change is older then anything we know, discard.
		20	+ }
		21	+
		22	+ m_proposedChange = desiredChange;
		23	+ for (const auto& ch : m_timeline)
		24	+ {
		25	+ if (!m_proposedChange.processChange(ch, exclusiveUpdate))
		26	+ {
		27	+ break;
		28	+ }
		29	+ }
		30	+ if ( m_proposedChange.valid()
		31	+ && !m_timeline.empty()
		32	+ && m_proposedChange < m_timeline.back())
		33	+ {
		34	+ // reset the timestamp so that the proposed change will be the latest in the timeline when committed.
		35	+ auto ts = m_timeline.back().timestamp();
		36	+ m_proposedChange.setTimestamp(++ts);
		37	+ }
		38	+ return m_proposedChange;
		39	+}
		40	+
		41	+void Timeline::commit()
		42	+{
		43	+ if (m_proposedChange.valid())
		44	+ {
		45	+ m_timeline.push_back(m_proposedChange);
		46	+ m_proposedChange = OrmBatchChange {};
		47	+ }
		48	+}
		49	+

src/timeline.h 0 → 100644

View file @5251bf3

		1	+++ a/src/timeline.h
		1	+#ifndef OSDEV_COMPONENTS_TIMELINE_H
		2	+#define OSDEV_COMPONENTS_TIMELINE_H
		3	+
		4	+// boost
		5	+#include <boost/circular_buffer.hpp>
		6	+
		7	+#include "ormbatchchange.h"
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+
		12	+/**
		13	+ * @brief The timeline contains the changes that where made to a specific Batch/Merge update table.
		14	+ * Only a small number of changes is recorded. A change arrives that is older then the oldest recorded
		15	+ * change this change will not be considered.
		16	+ */
		17	+class Timeline
		18	+{
		19	+public:
		20	+ /**
		21	+ * @brief Creates an empty timeline.
		22	+ */
		23	+ Timeline();
		24	+
		25	+ // Non copyable, non movable.
		26	+ Timeline(const Timeline&) = delete;
		27	+ Timeline& operator=(const Timeline&) = delete;
		28	+ Timeline(Timeline&&) = delete;
		29	+ Timeline& operator=(Timeline&&) = delete;
		30	+
		31	+ /**
		32	+ * @brief Evaluate an incoming change against the already registered changes.
		33	+ * A previously evaluated change is discarded.
		34	+ * @param desiredChange The incoming change.
		35	+ * @param exclusiveUpdate Flag that indicates if this change should be evaluated in an exclusive manner.
		36	+ * @return The reshaped and possibly invalidated change that is left.
		37	+ * @note The evaluated change is cached so that it can be commited if the database update actually succeeds.
		38	+ */
		39	+ const OrmBatchChange& evaluate(const OrmBatchChange& desiredChange, bool exclusiveUpdate);
		40	+
		41	+ /**
		42	+ * @brief Commit an evaluated change.
		43	+ * Only valid proposals are commited. This method should be called when the change
		44	+ * is sucessfuly written to the database.
		45	+ * @note To make this somewhat trustworthy the underlying database should support transactions.
		46	+ */
		47	+ void commit();
		48	+
		49	+private:
		50	+ boost::circular_buffer<OrmBatchChange> m_timeline; ///< Only a small number of changes are buffered.
		51	+ OrmBatchChange m_proposedChange; ///< Cache the evaluated proposed change for commiting.
		52	+};
		53	+
		54	+} /* End namespace components */
		55	+} /* End namespace osdev */
		56	+
		57	+#endif /* OSDEV_COMPONENTS_TIMELINE_H */

src/timestamp.cpp 0 → 100644

View file @5251bf3

		1	+++ a/src/timestamp.cpp
		1	+/* ****************************************************************************
		2	+ * Copyright 2019 Open Systems Development BV *
		3	+ * *
		4	+ * Permission is hereby granted, free of charge, to any person obtaining a *
		5	+ * copy of this software and associated documentation files (the "Software"), *
		6	+ * to deal in the Software without restriction, including without limitation *
		7	+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
		8	+ * and/or sell copies of the Software, and to permit persons to whom the *
		9	+ * Software is furnished to do so, subject to the following conditions: *
		10	+ * *
		11	+ * The above copyright notice and this permission notice shall be included in *
		12	+ * all copies or substantial portions of the Software. *
		13	+ * *
		14	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
		15	+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
		16	+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
		17	+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
		18	+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
		19	+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *
		20	+ * DEALINGS IN THE SOFTWARE. *
		21	+ * ***************************************************************************/
		22	+#include "timestamp.h"
		23	+
		24	+using namespace osdev::components;
		25	+
		26	+Timestamp::Timestamp()
		27	+ : m_msecsSinceEpoch(0)
		28	+ , m_seqNr(0)
		29	+{
		30	+}
		31	+
		32	+Timestamp::Timestamp(unsigned long long msecsSinceEpoch)
		33	+ : m_msecsSinceEpoch(msecsSinceEpoch)
		34	+ , m_seqNr(1)
		35	+{
		36	+}
		37	+
		38	+bool Timestamp::operator<(const Timestamp& rhs) const
		39	+{
		40	+ if (m_msecsSinceEpoch < rhs.m_msecsSinceEpoch)
		41	+ {
		42	+ return true;
		43	+ }
		44	+
		45	+ if (m_msecsSinceEpoch == rhs.m_msecsSinceEpoch)
		46	+ {
		47	+ return m_seqNr < rhs.m_seqNr;
		48	+ }
		49	+ return false;
		50	+}
		51	+
		52	+Timestamp& Timestamp::operator++() // prefix
		53	+{
		54	+ if (!valid())
		55	+ {
		56	+ return *this; // an invalid timestamp can only be made valid by assigning a valid timestamp to it.
		57	+ }
		58	+
		59	+ if (m_seqNr < std::numeric_limits<decltype(m_seqNr)>::max())
		60	+ {
		61	+ ++m_seqNr;
		62	+ }
		63	+ else
		64	+ {
		65	+ // The idea is to never reach this point by choosing a large datatype.
		66	+ // Overflowing is not an option because then the < relation doesn't hold anymore.
		67	+ throw std::out_of_range("sequence number overflow");
		68	+ }
		69	+ return *this;
		70	+}
		71	+
		72	+Timestamp Timestamp::operator++(int) // postfix
		73	+{
		74	+ auto cpy(*this);
		75	+ ++(*this);
		76	+ return cpy;
		77	+}
		78	+
		79	+QString Timestamp::toString() const
		80	+{
		81	+ return QString("%1:%2").arg(m_msecsSinceEpoch).arg(m_seqNr);
		82	+}
		83	+

src/timestamp.h 0 → 100644

View file @5251bf3

		1	+++ a/src/timestamp.h
		1	+#ifndef OSDEV_COMPONENTS_TIMESTAMP_H
		2	+#define OSDEV_COMPONENTS_TIMESTAMP_H
		3	+
		4	+#include <limits>
		5	+#include <stdexcept>
		6	+
		7	+#include <QString>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+
		12	+/**
		13	+ * @brief Timestamp class that allows formation of a sequence of ordered events.
		14	+ */
		15	+class Timestamp
		16	+{
		17	+public:
		18	+ /**
		19	+ * @brief Creates an invalid timestamp. This is the oldest possible timestamp.
		20	+ * @note A timestamp can only become valid by assigning a valid timestamp to it.
		21	+ */
		22	+ Timestamp();
		23	+
		24	+ /**
		25	+ * @brief Creates a timestamp based on miliseconds since the epoch.
		26	+ * @param msecsSinceEpoch Number of miliseconds since the epoch. Value 0 leads to valid timestamp.
		27	+ * @note Timestamp with value 0 is larger then the invalid timestamp.
		28	+ */
		29	+ explicit Timestamp(unsigned long long msecsSinceEpoch);
		30	+
		31	+
		32	+ // default constructable and movable.
		33	+ Timestamp(const Timestamp&) = default;
		34	+ Timestamp& operator=(const Timestamp&) = default;
		35	+ Timestamp(Timestamp&&) = default;
		36	+ Timestamp& operator=(Timestamp&&) = default;
		37	+
		38	+ /**
		39	+ * @return true if this timestamp is valid, false otherwise.
		40	+ */
		41	+ bool valid() const
		42	+ {
		43	+ return (m_seqNr > 0);
		44	+ }
		45	+
		46	+ /**
		47	+ * @return true if this timestamp is smaller (older) then rhs.
		48	+ */
		49	+ bool operator<(const Timestamp& rhs) const;
		50	+
		51	+ /**
		52	+ * @brief Prefix addition operator.
		53	+ * Increases the Timestamp sequencenumber so that timestamps with the same number of msecs since the epoch can also be ordered.
		54	+ * @note An invalid timestamp remains invalid.
		55	+ * @return Reference to this timestamp.
		56	+ * @throw std::out_of_range exception when seqnr is about to overflow.
		57	+ */
		58	+ Timestamp& operator++();
		59	+
		60	+ /**
		61	+ * @brief Postfix addition operator.
		62	+ * Increases the Timestamp sequencenumber so that timestamps with the same number of msecs since the epoch can also be ordered.
		63	+ * @note An invalid timestamp remains invalid.
		64	+ * @return The timestamp as it was before increment.
		65	+ * @throw std::out_of_range exception when seqnr is about to overflow.
		66	+ */
		67	+ Timestamp operator++(int);
		68	+
		69	+ /**
		70	+ * @return Stringified timestamp as msecsSinceEpoch:seqNr.
		71	+ */
		72	+ QString toString() const;
		73	+
		74	+private:
		75	+ unsigned long long m_msecsSinceEpoch; ///< Number of miliseconds since the epoch.
		76	+ unsigned long long m_seqNr; ///< Sequence number.
		77	+};
		78	+
		79	+} /* End namespace components */
		80	+} /* End namespace osdev */
		81	+
		82	+#endif /* OSDEV_COMPONENTS_TIMESTAMP_H */

tests/CMakeLists.txt 0 → 100644

View file @5251bf3

		1	+++ a/tests/CMakeLists.txt
		1	+cmake_minimum_required(VERSION 3.0)
		2	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../cmake)
		3	+
		4	+include(projectheader)
		5	+project_header(test_logutils)
		6	+
		7	+include_directories( SYSTEM
		8	+ ${CMAKE_CURRENT_SOURCE_DIR}/../../src
		9	+)
		10	+
		11	+include(compiler)
		12	+set(SRC_LIST
		13	+)
		14	+
		15	+# add_executable( ${PROJECT_NAME}
		16	+# ${SRC_LIST}
		17	+# )
		18	+
		19	+# target_link_libraries(
		20	+# ${PROJECT_NAME}
		21	+# )
		22	+
		23	+# set_target_properties( ${PROJECT_NAME} PROPERTIES
		24	+# RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
		25	+# LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
		26	+# ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/archive
		27	+# )
		28	+
		29	+# include(installation)
		30	+# install_application()