/**
  * @RDE_HEADER@
  * Template for 'real' structures including insert/update/delete functions for db
  * $Id$
  * $HeadURL$
  * $Author$
  */


// filename: pdm_db_impl.h
#pragma once

#include <QPointF>
#include <QString>
#include <QVector>
#include <QSqlDriver>
#include <QSqlDatabase>
#include <QtSql/QSqlError>

#include <ProjectDataManagement/pdm_enums.hpp>
#include <ProjectDataManagement/pdm_db.h>
#include <ProjectDataManagement/logger.h>

class NSqlQuery;
namespace ProjectDataManagement
{
class PDM_COMMON_EXPORT DatabaseInterfaceImpl final : public DatabaseInterface
{
  Q_OBJECT
public:
  explicit DatabaseInterfaceImpl(int exerciseId);
  ~DatabaseInterfaceImpl();

  bool init(const QSqlDatabase &dbConnection) override final;
  bool init(const QString &dbUser,
            const QString &dbPasswd,
            const QString &dbDriver,
            const QString &dbHost,
            const QString &dbName) override final;

  QString schemaName() const override final;
  QString dbUser() const override final;
  const QSqlDatabase &database() const override final { return m_dbConnection; }
  void setEmitMessageOnError(bool bEmit) override final;
  QSqlError getLastError() const override final;

  

  // Database::PdmAvmFrequencyPlanTransmissionReason
  bool insert(Database::PdmAvmFrequencyPlanTransmissionReason &data) override final;
  bool upsert(Database::PdmAvmFrequencyPlanTransmissionReason &data) override final;
  bool update(const Database::PdmAvmFrequencyPlanTransmissionReason &data) override final;

  bool insert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) override final;
  bool upsert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) override final;
  bool update(const std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont) override final;

  bool select(QVector<Database::PdmAvmFrequencyPlanTransmissionReason> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmAvmFrequencyPlanTransmissionReason &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmAvmFrequencyPlanTransmissionReason(const QString &where);
  bool selectFetchInternalPdmAvmFrequencyPlanTransmissionReason(const std::function<void(const Database::PdmAvmFrequencyPlanTransmissionReason &data)> &cb);
public:
  bool selectPdmAvmFrequencyPlanTransmissionReason(qint32 id, Database::PdmAvmFrequencyPlanTransmissionReason &data) override final;
  bool removePdmAvmFrequencyPlanTransmissionReason(qint32 id) override final;
  bool fixUpSequencePdmAvmFrequencyPlanTransmissionReason() override final;
  bool truncatePdmAvmFrequencyPlanTransmissionReason() override final;
  // Database::PdmAvmFrequencyPlanTransmissionReason
  

  // Database::PdmBiteComponentText
  bool insert(Database::PdmBiteComponentText &data) override final;
  bool upsert(Database::PdmBiteComponentText &data) override final;
  bool update(const Database::PdmBiteComponentText &data) override final;

  bool insert(std::vector<Database::PdmBiteComponentText> &cont) override final;
  bool upsert(std::vector<Database::PdmBiteComponentText> &cont) override final;
  bool update(const std::vector<Database::PdmBiteComponentText> &cont) override final;

  bool select(QVector<Database::PdmBiteComponentText> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmBiteComponentText &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmBiteComponentText(const QString &where);
  bool selectFetchInternalPdmBiteComponentText(const std::function<void(const Database::PdmBiteComponentText &data)> &cb);
public:
  bool selectPdmBiteComponentText(qint32 id, Database::PdmBiteComponentText &data) override final;
  bool removePdmBiteComponentText(qint32 id) override final;
  bool fixUpSequencePdmBiteComponentText() override final;
  bool truncatePdmBiteComponentText() override final;
  // Database::PdmBiteComponentText
  

  // Database::PdmBuildingChargeEffect
  bool insert(Database::PdmBuildingChargeEffect &data) override final;
  bool upsert(Database::PdmBuildingChargeEffect &data) override final;
  bool update(const Database::PdmBuildingChargeEffect &data) override final;

  bool insert(std::vector<Database::PdmBuildingChargeEffect> &cont) override final;
  bool upsert(std::vector<Database::PdmBuildingChargeEffect> &cont) override final;
  bool update(const std::vector<Database::PdmBuildingChargeEffect> &cont) override final;

  bool select(QVector<Database::PdmBuildingChargeEffect> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmBuildingChargeEffect &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmBuildingChargeEffect(const QString &where);
  bool selectFetchInternalPdmBuildingChargeEffect(const std::function<void(const Database::PdmBuildingChargeEffect &data)> &cb);
public:
  bool selectPdmBuildingChargeEffect(qint32 id, Database::PdmBuildingChargeEffect &data) override final;
  bool removePdmBuildingChargeEffect(qint32 id) override final;
  bool fixUpSequencePdmBuildingChargeEffect() override final;
  bool truncatePdmBuildingChargeEffect() override final;
  // Database::PdmBuildingChargeEffect
  

  // Database::PdmCanComponentString
  bool insert(Database::PdmCanComponentString &data) override final;
  bool upsert(Database::PdmCanComponentString &data) override final;
  bool update(const Database::PdmCanComponentString &data) override final;

  bool insert(std::vector<Database::PdmCanComponentString> &cont) override final;
  bool upsert(std::vector<Database::PdmCanComponentString> &cont) override final;
  bool update(const std::vector<Database::PdmCanComponentString> &cont) override final;

  bool select(QVector<Database::PdmCanComponentString> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmCanComponentString &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmCanComponentString(const QString &where);
  bool selectFetchInternalPdmCanComponentString(const std::function<void(const Database::PdmCanComponentString &data)> &cb);
public:
  bool selectPdmCanComponentString(qint32 id, Database::PdmCanComponentString &data) override final;
  bool removePdmCanComponentString(qint32 id) override final;
  bool fixUpSequencePdmCanComponentString() override final;
  bool truncatePdmCanComponentString() override final;
  // Database::PdmCanComponentString
  

  // Database::PdmChargeType
  bool insert(Database::PdmChargeType &data) override final;
  bool upsert(Database::PdmChargeType &data) override final;
  bool update(const Database::PdmChargeType &data) override final;

  bool insert(std::vector<Database::PdmChargeType> &cont) override final;
  bool upsert(std::vector<Database::PdmChargeType> &cont) override final;
  bool update(const std::vector<Database::PdmChargeType> &cont) override final;

  bool select(QVector<Database::PdmChargeType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmChargeType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmChargeType(const QString &where);
  bool selectFetchInternalPdmChargeType(const std::function<void(const Database::PdmChargeType &data)> &cb);
public:
  bool selectPdmChargeType(qint32 id, Database::PdmChargeType &data) override final;
  bool removePdmChargeType(qint32 id) override final;
  bool fixUpSequencePdmChargeType() override final;
  bool truncatePdmChargeType() override final;
  // Database::PdmChargeType
  

  // Database::PdmChargeTypeIgniterTypeIgniterFunction
  bool insert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data) override final;
  bool upsert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data) override final;
  bool update(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data) override final;

  bool insert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) override final;
  bool upsert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) override final;
  bool update(const std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont) override final;

  bool select(QVector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmChargeTypeIgniterTypeIgniterFunction(const QString &where);
  bool selectFetchInternalPdmChargeTypeIgniterTypeIgniterFunction(const std::function<void(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)> &cb);
public:
  bool selectPdmChargeTypeIgniterTypeIgniterFunction(qint32 id, Database::PdmChargeTypeIgniterTypeIgniterFunction &data) override final;
  bool removePdmChargeTypeIgniterTypeIgniterFunction(qint32 id) override final;
  bool fixUpSequencePdmChargeTypeIgniterTypeIgniterFunction() override final;
  bool truncatePdmChargeTypeIgniterTypeIgniterFunction() override final;
  // Database::PdmChargeTypeIgniterTypeIgniterFunction
  

  // Database::PdmChargeTypeLoadType
  bool insert(Database::PdmChargeTypeLoadType &data) override final;
  bool upsert(Database::PdmChargeTypeLoadType &data) override final;
  bool update(const Database::PdmChargeTypeLoadType &data) override final;

  bool insert(std::vector<Database::PdmChargeTypeLoadType> &cont) override final;
  bool upsert(std::vector<Database::PdmChargeTypeLoadType> &cont) override final;
  bool update(const std::vector<Database::PdmChargeTypeLoadType> &cont) override final;

  bool select(QVector<Database::PdmChargeTypeLoadType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmChargeTypeLoadType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmChargeTypeLoadType(const QString &where);
  bool selectFetchInternalPdmChargeTypeLoadType(const std::function<void(const Database::PdmChargeTypeLoadType &data)> &cb);
public:
  bool selectPdmChargeTypeLoadType(qint32 id, Database::PdmChargeTypeLoadType &data) override final;
  bool removePdmChargeTypeLoadType(qint32 id) override final;
  bool fixUpSequencePdmChargeTypeLoadType() override final;
  bool truncatePdmChargeTypeLoadType() override final;
  // Database::PdmChargeTypeLoadType
  

  // Database::PdmEquipmentSystemEventFilter
  bool insert(Database::PdmEquipmentSystemEventFilter &data) override final;
  bool upsert(Database::PdmEquipmentSystemEventFilter &data) override final;
  bool update(const Database::PdmEquipmentSystemEventFilter &data) override final;

  bool insert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont) override final;
  bool upsert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont) override final;
  bool update(const std::vector<Database::PdmEquipmentSystemEventFilter> &cont) override final;

  bool select(QVector<Database::PdmEquipmentSystemEventFilter> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmEquipmentSystemEventFilter &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmEquipmentSystemEventFilter(const QString &where);
  bool selectFetchInternalPdmEquipmentSystemEventFilter(const std::function<void(const Database::PdmEquipmentSystemEventFilter &data)> &cb);
public:
  bool selectPdmEquipmentSystemEventFilter(qint32 id, Database::PdmEquipmentSystemEventFilter &data) override final;
  bool removePdmEquipmentSystemEventFilter(qint32 id) override final;
  bool fixUpSequencePdmEquipmentSystemEventFilter() override final;
  bool truncatePdmEquipmentSystemEventFilter() override final;
  // Database::PdmEquipmentSystemEventFilter
  

  // Database::PdmEventFilterHgrMineSearch
  bool insert(Database::PdmEventFilterHgrMineSearch &data) override final;
  bool upsert(Database::PdmEventFilterHgrMineSearch &data) override final;
  bool update(const Database::PdmEventFilterHgrMineSearch &data) override final;

  bool insert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont) override final;
  bool upsert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont) override final;
  bool update(const std::vector<Database::PdmEventFilterHgrMineSearch> &cont) override final;

  bool select(QVector<Database::PdmEventFilterHgrMineSearch> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmEventFilterHgrMineSearch &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmEventFilterHgrMineSearch(const QString &where);
  bool selectFetchInternalPdmEventFilterHgrMineSearch(const std::function<void(const Database::PdmEventFilterHgrMineSearch &data)> &cb);
public:
  bool selectPdmEventFilterHgrMineSearch(qint32 id, Database::PdmEventFilterHgrMineSearch &data) override final;
  bool removePdmEventFilterHgrMineSearch(qint32 id) override final;
  bool fixUpSequencePdmEventFilterHgrMineSearch() override final;
  bool truncatePdmEventFilterHgrMineSearch() override final;
  // Database::PdmEventFilterHgrMineSearch
  

  // Database::PdmFirePurpose
  bool insert(Database::PdmFirePurpose &data) override final;
  bool upsert(Database::PdmFirePurpose &data) override final;
  bool update(const Database::PdmFirePurpose &data) override final;

  bool insert(std::vector<Database::PdmFirePurpose> &cont) override final;
  bool upsert(std::vector<Database::PdmFirePurpose> &cont) override final;
  bool update(const std::vector<Database::PdmFirePurpose> &cont) override final;

  bool select(QVector<Database::PdmFirePurpose> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmFirePurpose &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmFirePurpose(const QString &where);
  bool selectFetchInternalPdmFirePurpose(const std::function<void(const Database::PdmFirePurpose &data)> &cb);
public:
  bool selectPdmFirePurpose(qint32 id, Database::PdmFirePurpose &data) override final;
  bool removePdmFirePurpose(qint32 id) override final;
  bool fixUpSequencePdmFirePurpose() override final;
  bool truncatePdmFirePurpose() override final;
  // Database::PdmFirePurpose
  

  // Database::PdmGearType
  bool insert(Database::PdmGearType &data) override final;
  bool upsert(Database::PdmGearType &data) override final;
  bool update(const Database::PdmGearType &data) override final;

  bool insert(std::vector<Database::PdmGearType> &cont) override final;
  bool upsert(std::vector<Database::PdmGearType> &cont) override final;
  bool update(const std::vector<Database::PdmGearType> &cont) override final;

  bool select(QVector<Database::PdmGearType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmGearType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmGearType(const QString &where);
  bool selectFetchInternalPdmGearType(const std::function<void(const Database::PdmGearType &data)> &cb);
public:
  bool selectPdmGearType(qint32 id, Database::PdmGearType &data) override final;
  bool removePdmGearType(qint32 id) override final;
  bool fixUpSequencePdmGearType() override final;
  bool truncatePdmGearType() override final;
  // Database::PdmGearType
  

  // Database::PdmGearTypeChargeType
  bool insert(Database::PdmGearTypeChargeType &data) override final;
  bool upsert(Database::PdmGearTypeChargeType &data) override final;
  bool update(const Database::PdmGearTypeChargeType &data) override final;

  bool insert(std::vector<Database::PdmGearTypeChargeType> &cont) override final;
  bool upsert(std::vector<Database::PdmGearTypeChargeType> &cont) override final;
  bool update(const std::vector<Database::PdmGearTypeChargeType> &cont) override final;

  bool select(QVector<Database::PdmGearTypeChargeType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmGearTypeChargeType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmGearTypeChargeType(const QString &where);
  bool selectFetchInternalPdmGearTypeChargeType(const std::function<void(const Database::PdmGearTypeChargeType &data)> &cb);
public:
  bool selectPdmGearTypeChargeType(qint32 id, Database::PdmGearTypeChargeType &data) override final;
  bool removePdmGearTypeChargeType(qint32 id) override final;
  bool fixUpSequencePdmGearTypeChargeType() override final;
  bool truncatePdmGearTypeChargeType() override final;
  // Database::PdmGearTypeChargeType
  

  // Database::PdmIgniterFunction
  bool insert(Database::PdmIgniterFunction &data) override final;
  bool upsert(Database::PdmIgniterFunction &data) override final;
  bool update(const Database::PdmIgniterFunction &data) override final;

  bool insert(std::vector<Database::PdmIgniterFunction> &cont) override final;
  bool upsert(std::vector<Database::PdmIgniterFunction> &cont) override final;
  bool update(const std::vector<Database::PdmIgniterFunction> &cont) override final;

  bool select(QVector<Database::PdmIgniterFunction> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmIgniterFunction &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmIgniterFunction(const QString &where);
  bool selectFetchInternalPdmIgniterFunction(const std::function<void(const Database::PdmIgniterFunction &data)> &cb);
public:
  bool selectPdmIgniterFunction(qint32 id, Database::PdmIgniterFunction &data) override final;
  bool removePdmIgniterFunction(qint32 id) override final;
  bool fixUpSequencePdmIgniterFunction() override final;
  bool truncatePdmIgniterFunction() override final;
  // Database::PdmIgniterFunction
  

  // Database::PdmIgniterType
  bool insert(Database::PdmIgniterType &data) override final;
  bool upsert(Database::PdmIgniterType &data) override final;
  bool update(const Database::PdmIgniterType &data) override final;

  bool insert(std::vector<Database::PdmIgniterType> &cont) override final;
  bool upsert(std::vector<Database::PdmIgniterType> &cont) override final;
  bool update(const std::vector<Database::PdmIgniterType> &cont) override final;

  bool select(QVector<Database::PdmIgniterType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmIgniterType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmIgniterType(const QString &where);
  bool selectFetchInternalPdmIgniterType(const std::function<void(const Database::PdmIgniterType &data)> &cb);
public:
  bool selectPdmIgniterType(qint32 id, Database::PdmIgniterType &data) override final;
  bool removePdmIgniterType(qint32 id) override final;
  bool fixUpSequencePdmIgniterType() override final;
  bool truncatePdmIgniterType() override final;
  // Database::PdmIgniterType
  

  // Database::PdmLanguage
  bool insert(Database::PdmLanguage &data) override final;
  bool upsert(Database::PdmLanguage &data) override final;
  bool update(const Database::PdmLanguage &data) override final;

  bool insert(std::vector<Database::PdmLanguage> &cont) override final;
  bool upsert(std::vector<Database::PdmLanguage> &cont) override final;
  bool update(const std::vector<Database::PdmLanguage> &cont) override final;

  bool select(QVector<Database::PdmLanguage> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmLanguage &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmLanguage(const QString &where);
  bool selectFetchInternalPdmLanguage(const std::function<void(const Database::PdmLanguage &data)> &cb);
public:
  bool selectPdmLanguage(qint32 id, Database::PdmLanguage &data) override final;
  bool removePdmLanguage(qint32 id) override final;
  bool fixUpSequencePdmLanguage() override final;
  bool truncatePdmLanguage() override final;
  // Database::PdmLanguage
  

  // Database::PdmLanguageXdu
  bool insert(Database::PdmLanguageXdu &data) override final;
  bool upsert(Database::PdmLanguageXdu &data) override final;
  bool update(const Database::PdmLanguageXdu &data) override final;

  bool insert(std::vector<Database::PdmLanguageXdu> &cont) override final;
  bool upsert(std::vector<Database::PdmLanguageXdu> &cont) override final;
  bool update(const std::vector<Database::PdmLanguageXdu> &cont) override final;

  bool select(QVector<Database::PdmLanguageXdu> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmLanguageXdu &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmLanguageXdu(const QString &where);
  bool selectFetchInternalPdmLanguageXdu(const std::function<void(const Database::PdmLanguageXdu &data)> &cb);
public:
  bool selectPdmLanguageXdu(qint32 id, Database::PdmLanguageXdu &data) override final;
  bool removePdmLanguageXdu(qint32 id) override final;
  bool fixUpSequencePdmLanguageXdu() override final;
  bool truncatePdmLanguageXdu() override final;
  // Database::PdmLanguageXdu
  

  // Database::PdmLoadType
  bool insert(Database::PdmLoadType &data) override final;
  bool upsert(Database::PdmLoadType &data) override final;
  bool update(const Database::PdmLoadType &data) override final;

  bool insert(std::vector<Database::PdmLoadType> &cont) override final;
  bool upsert(std::vector<Database::PdmLoadType> &cont) override final;
  bool update(const std::vector<Database::PdmLoadType> &cont) override final;

  bool select(QVector<Database::PdmLoadType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmLoadType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmLoadType(const QString &where);
  bool selectFetchInternalPdmLoadType(const std::function<void(const Database::PdmLoadType &data)> &cb);
public:
  bool selectPdmLoadType(qint32 id, Database::PdmLoadType &data) override final;
  bool removePdmLoadType(qint32 id) override final;
  bool fixUpSequencePdmLoadType() override final;
  bool truncatePdmLoadType() override final;
  // Database::PdmLoadType
  

  // Database::PdmNuclearPreset
  bool insert(Database::PdmNuclearPreset &data) override final;
  bool upsert(Database::PdmNuclearPreset &data) override final;
  bool update(const Database::PdmNuclearPreset &data) override final;

  bool insert(std::vector<Database::PdmNuclearPreset> &cont) override final;
  bool upsert(std::vector<Database::PdmNuclearPreset> &cont) override final;
  bool update(const std::vector<Database::PdmNuclearPreset> &cont) override final;

  bool select(QVector<Database::PdmNuclearPreset> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmNuclearPreset &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmNuclearPreset(const QString &where);
  bool selectFetchInternalPdmNuclearPreset(const std::function<void(const Database::PdmNuclearPreset &data)> &cb);
public:
  bool selectPdmNuclearPreset(qint32 id, Database::PdmNuclearPreset &data) override final;
  bool removePdmNuclearPreset(qint32 id) override final;
  bool fixUpSequencePdmNuclearPreset() override final;
  bool truncatePdmNuclearPreset() override final;
  // Database::PdmNuclearPreset
  

  // Database::PdmRadioGroup
  bool insert(Database::PdmRadioGroup &data) override final;
  bool upsert(Database::PdmRadioGroup &data) override final;
  bool update(const Database::PdmRadioGroup &data) override final;

  bool insert(std::vector<Database::PdmRadioGroup> &cont) override final;
  bool upsert(std::vector<Database::PdmRadioGroup> &cont) override final;
  bool update(const std::vector<Database::PdmRadioGroup> &cont) override final;

  bool select(QVector<Database::PdmRadioGroup> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmRadioGroup &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmRadioGroup(const QString &where);
  bool selectFetchInternalPdmRadioGroup(const std::function<void(const Database::PdmRadioGroup &data)> &cb);
public:
  bool selectPdmRadioGroup(qint32 id, Database::PdmRadioGroup &data) override final;
  bool removePdmRadioGroup(qint32 id) override final;
  bool fixUpSequencePdmRadioGroup() override final;
  bool truncatePdmRadioGroup() override final;
  // Database::PdmRadioGroup
  

  // Database::PdmSanitationInjury
  bool insert(Database::PdmSanitationInjury &data) override final;
  bool upsert(Database::PdmSanitationInjury &data) override final;
  bool update(const Database::PdmSanitationInjury &data) override final;

  bool insert(std::vector<Database::PdmSanitationInjury> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationInjury> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationInjury> &cont) override final;

  bool select(QVector<Database::PdmSanitationInjury> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationInjury &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationInjury(const QString &where);
  bool selectFetchInternalPdmSanitationInjury(const std::function<void(const Database::PdmSanitationInjury &data)> &cb);
public:
  bool selectPdmSanitationInjury(qint32 id, Database::PdmSanitationInjury &data) override final;
  bool removePdmSanitationInjury(qint32 id) override final;
  bool fixUpSequencePdmSanitationInjury() override final;
  bool truncatePdmSanitationInjury() override final;
  // Database::PdmSanitationInjury
  

  // Database::PdmSanitationInjuryKind
  bool insert(Database::PdmSanitationInjuryKind &data) override final;
  bool upsert(Database::PdmSanitationInjuryKind &data) override final;
  bool update(const Database::PdmSanitationInjuryKind &data) override final;

  bool insert(std::vector<Database::PdmSanitationInjuryKind> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationInjuryKind> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationInjuryKind> &cont) override final;

  bool select(QVector<Database::PdmSanitationInjuryKind> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationInjuryKind &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationInjuryKind(const QString &where);
  bool selectFetchInternalPdmSanitationInjuryKind(const std::function<void(const Database::PdmSanitationInjuryKind &data)> &cb);
public:
  bool selectPdmSanitationInjuryKind(qint32 id, Database::PdmSanitationInjuryKind &data) override final;
  bool removePdmSanitationInjuryKind(qint32 id) override final;
  bool fixUpSequencePdmSanitationInjuryKind() override final;
  bool truncatePdmSanitationInjuryKind() override final;
  // Database::PdmSanitationInjuryKind
  

  // Database::PdmSanitationInjuryPlace1
  bool insert(Database::PdmSanitationInjuryPlace1 &data) override final;
  bool upsert(Database::PdmSanitationInjuryPlace1 &data) override final;
  bool update(const Database::PdmSanitationInjuryPlace1 &data) override final;

  bool insert(std::vector<Database::PdmSanitationInjuryPlace1> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationInjuryPlace1> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationInjuryPlace1> &cont) override final;

  bool select(QVector<Database::PdmSanitationInjuryPlace1> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationInjuryPlace1 &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationInjuryPlace1(const QString &where);
  bool selectFetchInternalPdmSanitationInjuryPlace1(const std::function<void(const Database::PdmSanitationInjuryPlace1 &data)> &cb);
public:
  bool selectPdmSanitationInjuryPlace1(qint32 id, Database::PdmSanitationInjuryPlace1 &data) override final;
  bool removePdmSanitationInjuryPlace1(qint32 id) override final;
  bool fixUpSequencePdmSanitationInjuryPlace1() override final;
  bool truncatePdmSanitationInjuryPlace1() override final;
  // Database::PdmSanitationInjuryPlace1
  

  // Database::PdmSanitationInjuryPlace2
  bool insert(Database::PdmSanitationInjuryPlace2 &data) override final;
  bool upsert(Database::PdmSanitationInjuryPlace2 &data) override final;
  bool update(const Database::PdmSanitationInjuryPlace2 &data) override final;

  bool insert(std::vector<Database::PdmSanitationInjuryPlace2> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationInjuryPlace2> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationInjuryPlace2> &cont) override final;

  bool select(QVector<Database::PdmSanitationInjuryPlace2> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationInjuryPlace2 &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationInjuryPlace2(const QString &where);
  bool selectFetchInternalPdmSanitationInjuryPlace2(const std::function<void(const Database::PdmSanitationInjuryPlace2 &data)> &cb);
public:
  bool selectPdmSanitationInjuryPlace2(qint32 id, Database::PdmSanitationInjuryPlace2 &data) override final;
  bool removePdmSanitationInjuryPlace2(qint32 id) override final;
  bool fixUpSequencePdmSanitationInjuryPlace2() override final;
  bool truncatePdmSanitationInjuryPlace2() override final;
  // Database::PdmSanitationInjuryPlace2
  

  // Database::PdmSanitationMaterial
  bool insert(Database::PdmSanitationMaterial &data) override final;
  bool upsert(Database::PdmSanitationMaterial &data) override final;
  bool update(const Database::PdmSanitationMaterial &data) override final;

  bool insert(std::vector<Database::PdmSanitationMaterial> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationMaterial> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationMaterial> &cont) override final;

  bool select(QVector<Database::PdmSanitationMaterial> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationMaterial &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationMaterial(const QString &where);
  bool selectFetchInternalPdmSanitationMaterial(const std::function<void(const Database::PdmSanitationMaterial &data)> &cb);
public:
  bool selectPdmSanitationMaterial(qint32 id, Database::PdmSanitationMaterial &data) override final;
  bool removePdmSanitationMaterial(qint32 id) override final;
  bool fixUpSequencePdmSanitationMaterial() override final;
  bool truncatePdmSanitationMaterial() override final;
  // Database::PdmSanitationMaterial
  

  // Database::PdmSanitationProcedures
  bool insert(Database::PdmSanitationProcedures &data) override final;
  bool upsert(Database::PdmSanitationProcedures &data) override final;
  bool update(const Database::PdmSanitationProcedures &data) override final;

  bool insert(std::vector<Database::PdmSanitationProcedures> &cont) override final;
  bool upsert(std::vector<Database::PdmSanitationProcedures> &cont) override final;
  bool update(const std::vector<Database::PdmSanitationProcedures> &cont) override final;

  bool select(QVector<Database::PdmSanitationProcedures> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmSanitationProcedures &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmSanitationProcedures(const QString &where);
  bool selectFetchInternalPdmSanitationProcedures(const std::function<void(const Database::PdmSanitationProcedures &data)> &cb);
public:
  bool selectPdmSanitationProcedures(qint32 id, Database::PdmSanitationProcedures &data) override final;
  bool removePdmSanitationProcedures(qint32 id) override final;
  bool fixUpSequencePdmSanitationProcedures() override final;
  bool truncatePdmSanitationProcedures() override final;
  // Database::PdmSanitationProcedures
  

  // Database::PdmTargetSubType
  bool insert(Database::PdmTargetSubType &data) override final;
  bool upsert(Database::PdmTargetSubType &data) override final;
  bool update(const Database::PdmTargetSubType &data) override final;

  bool insert(std::vector<Database::PdmTargetSubType> &cont) override final;
  bool upsert(std::vector<Database::PdmTargetSubType> &cont) override final;
  bool update(const std::vector<Database::PdmTargetSubType> &cont) override final;

  bool select(QVector<Database::PdmTargetSubType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmTargetSubType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmTargetSubType(const QString &where);
  bool selectFetchInternalPdmTargetSubType(const std::function<void(const Database::PdmTargetSubType &data)> &cb);
public:
  bool selectPdmTargetSubType(qint32 id, Database::PdmTargetSubType &data) override final;
  bool removePdmTargetSubType(qint32 id) override final;
  bool fixUpSequencePdmTargetSubType() override final;
  bool truncatePdmTargetSubType() override final;
  // Database::PdmTargetSubType
  

  // Database::PdmTargetType
  bool insert(Database::PdmTargetType &data) override final;
  bool upsert(Database::PdmTargetType &data) override final;
  bool update(const Database::PdmTargetType &data) override final;

  bool insert(std::vector<Database::PdmTargetType> &cont) override final;
  bool upsert(std::vector<Database::PdmTargetType> &cont) override final;
  bool update(const std::vector<Database::PdmTargetType> &cont) override final;

  bool select(QVector<Database::PdmTargetType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmTargetType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmTargetType(const QString &where);
  bool selectFetchInternalPdmTargetType(const std::function<void(const Database::PdmTargetType &data)> &cb);
public:
  bool selectPdmTargetType(qint32 id, Database::PdmTargetType &data) override final;
  bool removePdmTargetType(qint32 id) override final;
  bool fixUpSequencePdmTargetType() override final;
  bool truncatePdmTargetType() override final;
  // Database::PdmTargetType
  

  // Database::PdmTargetTypeTargetSubType
  bool insert(Database::PdmTargetTypeTargetSubType &data) override final;
  bool upsert(Database::PdmTargetTypeTargetSubType &data) override final;
  bool update(const Database::PdmTargetTypeTargetSubType &data) override final;

  bool insert(std::vector<Database::PdmTargetTypeTargetSubType> &cont) override final;
  bool upsert(std::vector<Database::PdmTargetTypeTargetSubType> &cont) override final;
  bool update(const std::vector<Database::PdmTargetTypeTargetSubType> &cont) override final;

  bool select(QVector<Database::PdmTargetTypeTargetSubType> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmTargetTypeTargetSubType &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmTargetTypeTargetSubType(const QString &where);
  bool selectFetchInternalPdmTargetTypeTargetSubType(const std::function<void(const Database::PdmTargetTypeTargetSubType &data)> &cb);
public:
  bool selectPdmTargetTypeTargetSubType(qint32 id, Database::PdmTargetTypeTargetSubType &data) override final;
  bool removePdmTargetTypeTargetSubType(qint32 id) override final;
  bool fixUpSequencePdmTargetTypeTargetSubType() override final;
  bool truncatePdmTargetTypeTargetSubType() override final;
  // Database::PdmTargetTypeTargetSubType
  

  // Database::PdmTranslation
  bool insert(Database::PdmTranslation &data) override final;
  bool upsert(Database::PdmTranslation &data) override final;
  bool update(const Database::PdmTranslation &data) override final;

  bool insert(std::vector<Database::PdmTranslation> &cont) override final;
  bool upsert(std::vector<Database::PdmTranslation> &cont) override final;
  bool update(const std::vector<Database::PdmTranslation> &cont) override final;

  bool select(QVector<Database::PdmTranslation> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmTranslation &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmTranslation(const QString &where);
  bool selectFetchInternalPdmTranslation(const std::function<void(const Database::PdmTranslation &data)> &cb);
public:
  bool selectPdmTranslation(qint32 id, Database::PdmTranslation &data) override final;
  bool removePdmTranslation(qint32 id) override final;
  bool fixUpSequencePdmTranslation() override final;
  bool truncatePdmTranslation() override final;
  // Database::PdmTranslation
  

  // Database::PdmVulnerabilityKind
  bool insert(Database::PdmVulnerabilityKind &data) override final;
  bool upsert(Database::PdmVulnerabilityKind &data) override final;
  bool update(const Database::PdmVulnerabilityKind &data) override final;

  bool insert(std::vector<Database::PdmVulnerabilityKind> &cont) override final;
  bool upsert(std::vector<Database::PdmVulnerabilityKind> &cont) override final;
  bool update(const std::vector<Database::PdmVulnerabilityKind> &cont) override final;

  bool select(QVector<Database::PdmVulnerabilityKind> &dataVec) override final;
  bool select(const std::function<void(const Database::PdmVulnerabilityKind &data)> &cb) override final;
protected:
  bool selectPrepareInternalPdmVulnerabilityKind(const QString &where);
  bool selectFetchInternalPdmVulnerabilityKind(const std::function<void(const Database::PdmVulnerabilityKind &data)> &cb);
public:
  bool selectPdmVulnerabilityKind(qint32 taVulnerabilityKind, Database::PdmVulnerabilityKind &data) override final;
  bool removePdmVulnerabilityKind(qint32 taVulnerabilityKind) override final;
  bool fixUpSequencePdmVulnerabilityKind() override final;
  bool truncatePdmVulnerabilityKind() override final;
  // Database::PdmVulnerabilityKind
  

  

protected:
  QString getTableName(const QString &tableName) const;

protected:
  QSqlDatabase m_dbConnection;
  std::unique_ptr<NSqlQuery> m_query;
  QSqlError m_lastError;
  int m_exerciseId;
  bool m_bEmitMessageOnError;
  bool m_bCanHandleSchemas;
  bool m_ownDatabaseConnection;
  LOGGER_T m_logger;
private:
  bool initInternal();
};// class DatabaseInterfaceImpl
} // namespace ProjectDataManagement