torstenandCopilot
7173785915
Major Changes:
- Merged latest Qt5 devel content from dlbo (292 files changed, 7 new dirs)
- Consolidated forward-declarations and include folders
- Removed unneeded modules per Niklas' repo check list
Build System Fixes:
- Fixed CMake VERSION_GREATER syntax in ParticipantManagement/CMakeLists.txt
- Added VLC packages (libvlc-dev, vlc-plugin-base) to docker_build.sh
- Added PostgreSQL dev packages (libpq-dev, postgresql-server-dev-all) to Dockerfile
- Fixed locale warnings (ANSI_X3.4-1968 → C.UTF-8)
- Fixed ArcGIS SDK path warnings when BUILD_ARCGIS=OFF
Code Generation Fixes:
- Fixed IDL enum collisions (PortType→CorePortType/DdsutPortType, PdmEventType)
- Fixed Grantlee template svc_translation.cpp.grantlee:
- Changed {{ idl_enum.name }}_def:: to {{ idl_enum.name }}::
- Fixed .underlying() calls for C++11 scoped enums (enum class)
- Removed generated files from repo (moc_*, *_dtc.h, *_ftc.h)
Validation:
- BUILD_RTI=ON: SUCCESS
- BUILD_RTI=OFF: SUCCESS
- C++17 standard maintained for RTI 7.7 compatibility
- Ubuntu 26.04 Docker environment verified
Remaining Warnings (expected):
- BgViewer, KDChart, KDReports, Poppler-Qt6 not found (optional features)
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
13145 lines
409 KiB
C++
13145 lines
409 KiB
C++
/**
|
|
* @RDE_HEADER@
|
|
* Template for 'real' structures including insert/update/delete functions for db
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
|
|
// filename: pdm_db_impl.cpp
|
|
#include "pdm_db_impl.h"
|
|
|
|
|
|
#include <ngldb/dbtransaction.h>
|
|
#include <ngldb/nsqlquery.h>
|
|
#include <ngldb/dbconnection.h>
|
|
#include <ngldb/sql_query_janitor.h>
|
|
#include <QtSql/QSqlError>
|
|
#include <QVariant>
|
|
#include <NGLLogger/INGLLogger.h>
|
|
|
|
namespace ProjectDataManagement
|
|
{
|
|
|
|
QString qVariantToJsonString(const QVariant &value)
|
|
{
|
|
return value.isNull() ? QStringLiteral("{}") : value.toString();
|
|
}
|
|
|
|
QString fixupEmptyJsonString(const QString &str)
|
|
{
|
|
return str.isEmpty() ? QStringLiteral("{}") : str;
|
|
}
|
|
|
|
// DatabaseInterface
|
|
std::shared_ptr<DatabaseInterface> DatabaseInterface::create(int exerciseId)
|
|
{
|
|
|
|
return std::make_shared<DatabaseInterfaceImpl>(exerciseId);
|
|
}
|
|
|
|
DatabaseInterfaceImpl::DatabaseInterfaceImpl(int exerciseId)
|
|
: m_query(nullptr)
|
|
, m_exerciseId(exerciseId)
|
|
, m_bEmitMessageOnError(true)
|
|
, m_bCanHandleSchemas(true)
|
|
, m_ownDatabaseConnection(true)
|
|
, m_logger(getLogger("Db"))
|
|
{}
|
|
|
|
DatabaseInterfaceImpl::~DatabaseInterfaceImpl()
|
|
{
|
|
m_query = nullptr;
|
|
|
|
if (m_ownDatabaseConnection && m_dbConnection.isOpen())
|
|
m_dbConnection.close();
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::init(const QSqlDatabase &dbConnection)
|
|
{
|
|
m_dbConnection = dbConnection;
|
|
m_ownDatabaseConnection = false;
|
|
return initInternal();
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::init(const QString &dbUser,
|
|
const QString &dbPasswd,
|
|
const QString &dbDriver,
|
|
const QString &dbHost,
|
|
const QString &dbName)
|
|
{
|
|
m_ownDatabaseConnection = true;
|
|
|
|
m_dbConnection = DBConnection::open(m_logger, dbUser, dbPasswd, dbDriver, dbHost, dbName, schemaName());
|
|
|
|
return initInternal();
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::initInternal()
|
|
{
|
|
QSqlDriver *driver = m_dbConnection.driver();
|
|
if (!driver)
|
|
{
|
|
WARNING_LOG(m_logger) << "No SQL driver loaded - no database available!";
|
|
return false;
|
|
}
|
|
const QString driverName = m_dbConnection.driverName();
|
|
DEBUG_LOG(m_logger) << "Connected to database " << m_dbConnection.databaseName() << "@" << m_dbConnection.hostName()
|
|
<< ", schema: " << schemaName() << ", used driver: " << driverName;
|
|
if (!m_dbConnection.isOpen())
|
|
{
|
|
WARNING_LOG(m_logger) << "Database connection is no open - can not initialize database interface";
|
|
return false;
|
|
}
|
|
if (driverName == QLatin1String("QSQLITE"))
|
|
m_bCanHandleSchemas = false;
|
|
|
|
|
|
m_query = std::unique_ptr<NSqlQuery>(new NSqlQuery(m_dbConnection, m_logger));
|
|
return true;
|
|
}
|
|
|
|
QString DatabaseInterfaceImpl::schemaName() const
|
|
{
|
|
if (!m_bCanHandleSchemas)
|
|
return QString();
|
|
if (m_exerciseId <= 0)
|
|
return QStringLiteral("pdm");
|
|
return DBCommon::getExerciseSchemaName(m_exerciseId);
|
|
}
|
|
|
|
QString DatabaseInterfaceImpl::dbUser() const
|
|
{
|
|
if (m_exerciseId > 0)
|
|
return QStringLiteral("ets_ex_00");
|
|
else
|
|
return QStringLiteral("ets_") + schemaName();
|
|
}
|
|
|
|
void DatabaseInterfaceImpl::setEmitMessageOnError(bool bEmit)
|
|
{
|
|
m_bEmitMessageOnError = bEmit;
|
|
}
|
|
|
|
QString DatabaseInterfaceImpl::getTableName(const QString &tableName) const
|
|
{
|
|
if (!m_bCanHandleSchemas)
|
|
return tableName;
|
|
if (m_exerciseId > 0)
|
|
return DBCommon::getExerciseTableName(tableName, m_exerciseId);
|
|
return QStringLiteral("pdm.") + tableName;
|
|
}
|
|
|
|
QSqlError DatabaseInterfaceImpl::getLastError() const
|
|
{
|
|
return m_lastError;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Struct: Database::PdmAvmFrequencyPlanTransmissionReason
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmAvmFrequencyPlanTransmissionReason &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmAvmFrequencyPlanTransmissionReason &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmAvmFrequencyPlanTransmissionReason &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmAvmFrequencyPlanTransmissionReason();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmAvmFrequencyPlanTransmissionReason();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmAvmFrequencyPlanTransmissionReason> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmAvmFrequencyPlanTransmissionReason> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmAvmFrequencyPlanTransmissionReason &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmAvmFrequencyPlanTransmissionReason(QString()) && selectFetchInternalPdmAvmFrequencyPlanTransmissionReason(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmAvmFrequencyPlanTransmissionReason &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmAvmFrequencyPlanTransmissionReason(QString()) && selectFetchInternalPdmAvmFrequencyPlanTransmissionReason(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmAvmFrequencyPlanTransmissionReason(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("SELECT id, name"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmAvmFrequencyPlanTransmissionReason(const std::function<void(const Database::PdmAvmFrequencyPlanTransmissionReason &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmAvmFrequencyPlanTransmissionReason data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmAvmFrequencyPlanTransmissionReason(qint32 id, Database::PdmAvmFrequencyPlanTransmissionReason &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmAvmFrequencyPlanTransmissionReason &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmAvmFrequencyPlanTransmissionReason(where) || !selectFetchInternalPdmAvmFrequencyPlanTransmissionReason(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmAvmFrequencyPlanTransmissionReason(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmAvmFrequencyPlanTransmissionReason()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmAvmFrequencyPlanTransmissionReason()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_avm_frequency_plan_transmission_reason")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmAvmFrequencyPlanTransmissionReason end
|
|
|
|
//
|
|
// Struct: Database::PdmBiteComponentText
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmBiteComponentText &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" can_device_id, sub_device_id, error_number, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":can_device_id, :sub_device_id, :error_number, :name )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmBiteComponentText &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" can_device_id, sub_device_id, error_number, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":can_device_id, :sub_device_id, :error_number, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" can_device_id = :can_device_id, sub_device_id = :sub_device_id, error_number = :error_number, name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmBiteComponentText &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" can_device_id = :can_device_id, sub_device_id = :sub_device_id, error_number = :error_number, name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmBiteComponentText> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" can_device_id, sub_device_id, error_number, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":can_device_id, :sub_device_id, :error_number, :name )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmBiteComponentText();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmBiteComponentText> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" can_device_id, sub_device_id, error_number, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":can_device_id, :sub_device_id, :error_number, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" can_device_id = :can_device_id, sub_device_id = :sub_device_id, error_number = :error_number, name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmBiteComponentText();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmBiteComponentText> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" can_device_id = :can_device_id, sub_device_id = :sub_device_id, error_number = :error_number, name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":error_number"), data.errorNumber);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmBiteComponentText> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmBiteComponentText &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmBiteComponentText(QString()) && selectFetchInternalPdmBiteComponentText(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmBiteComponentText &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmBiteComponentText(QString()) && selectFetchInternalPdmBiteComponentText(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmBiteComponentText(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("SELECT id, can_device_id, sub_device_id, error_number, name"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmBiteComponentText(const std::function<void(const Database::PdmBiteComponentText &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmBiteComponentText data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.canDeviceId = m_query->value(i++).toInt();
|
|
data.subDeviceId = m_query->value(i++).toInt();
|
|
data.errorNumber = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmBiteComponentText(qint32 id, Database::PdmBiteComponentText &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmBiteComponentText &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmBiteComponentText(where) || !selectFetchInternalPdmBiteComponentText(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmBiteComponentText(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmBiteComponentText()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmBiteComponentText()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_bite_component_text")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmBiteComponentText end
|
|
|
|
//
|
|
// Struct: Database::PdmBuildingChargeEffect
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmBuildingChargeEffect &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, destructive_factor, penetration_factor, hit_sound, difcue_light, difcue_pyro"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :destructive_factor, :penetration_factor, :hit_sound, :difcue_light, :difcue_pyro )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmBuildingChargeEffect &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, destructive_factor, penetration_factor, hit_sound, difcue_light, difcue_pyro"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :destructive_factor, :penetration_factor, :hit_sound, :difcue_light, :difcue_pyro )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, destructive_factor = :destructive_factor, penetration_factor = :penetration_factor, hit_sound = :hit_sound, difcue_light = :difcue_light, difcue_pyro = :difcue_pyro"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmBuildingChargeEffect &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, destructive_factor = :destructive_factor, penetration_factor = :penetration_factor, hit_sound = :hit_sound, difcue_light = :difcue_light, difcue_pyro = :difcue_pyro"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmBuildingChargeEffect> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, destructive_factor, penetration_factor, hit_sound, difcue_light, difcue_pyro"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :destructive_factor, :penetration_factor, :hit_sound, :difcue_light, :difcue_pyro )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmBuildingChargeEffect();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmBuildingChargeEffect> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, destructive_factor, penetration_factor, hit_sound, difcue_light, difcue_pyro"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :destructive_factor, :penetration_factor, :hit_sound, :difcue_light, :difcue_pyro )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, destructive_factor = :destructive_factor, penetration_factor = :penetration_factor, hit_sound = :hit_sound, difcue_light = :difcue_light, difcue_pyro = :difcue_pyro"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmBuildingChargeEffect();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmBuildingChargeEffect> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, destructive_factor = :destructive_factor, penetration_factor = :penetration_factor, hit_sound = :hit_sound, difcue_light = :difcue_light, difcue_pyro = :difcue_pyro"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":destructive_factor"), data.destructiveFactor);
|
|
m_query->bindValue(QStringLiteral(":penetration_factor"), data.penetrationFactor);
|
|
m_query->bindValue(QStringLiteral(":hit_sound"), data.hitSound);
|
|
m_query->bindValue(QStringLiteral(":difcue_light"), data.difcueLight);
|
|
m_query->bindValue(QStringLiteral(":difcue_pyro"), data.difcuePyro);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmBuildingChargeEffect> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmBuildingChargeEffect &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmBuildingChargeEffect(QString()) && selectFetchInternalPdmBuildingChargeEffect(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmBuildingChargeEffect &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmBuildingChargeEffect(QString()) && selectFetchInternalPdmBuildingChargeEffect(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmBuildingChargeEffect(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("SELECT id, charge_type_id, destructive_factor, penetration_factor, hit_sound, difcue_light, difcue_pyro"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmBuildingChargeEffect(const std::function<void(const Database::PdmBuildingChargeEffect &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmBuildingChargeEffect data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.chargeTypeId = m_query->value(i++).toInt();
|
|
data.destructiveFactor = m_query->value(i++).toInt();
|
|
data.penetrationFactor = m_query->value(i++).toInt();
|
|
data.hitSound = m_query->value(i++).toInt();
|
|
data.difcueLight = m_query->value(i++).toBool();
|
|
data.difcuePyro = m_query->value(i++).toBool();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmBuildingChargeEffect(qint32 id, Database::PdmBuildingChargeEffect &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmBuildingChargeEffect &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmBuildingChargeEffect(where) || !selectFetchInternalPdmBuildingChargeEffect(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmBuildingChargeEffect(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmBuildingChargeEffect()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmBuildingChargeEffect()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_building_charge_effect")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmBuildingChargeEffect end
|
|
|
|
//
|
|
// Struct: Database::PdmCanComponentString
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmCanComponentString &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" bit_mask, can_device_id, sub_device_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":bit_mask, :can_device_id, :sub_device_id, :name )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmCanComponentString &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" bit_mask, can_device_id, sub_device_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":bit_mask, :can_device_id, :sub_device_id, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" bit_mask = :bit_mask, can_device_id = :can_device_id, sub_device_id = :sub_device_id, name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmCanComponentString &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" bit_mask = :bit_mask, can_device_id = :can_device_id, sub_device_id = :sub_device_id, name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmCanComponentString> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" bit_mask, can_device_id, sub_device_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":bit_mask, :can_device_id, :sub_device_id, :name )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmCanComponentString();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmCanComponentString> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" bit_mask, can_device_id, sub_device_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":bit_mask, :can_device_id, :sub_device_id, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" bit_mask = :bit_mask, can_device_id = :can_device_id, sub_device_id = :sub_device_id, name = :name"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmCanComponentString();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmCanComponentString> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" bit_mask = :bit_mask, can_device_id = :can_device_id, sub_device_id = :sub_device_id, name = :name"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":bit_mask"), data.bitMask);
|
|
m_query->bindValue(QStringLiteral(":can_device_id"), data.canDeviceId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmCanComponentString> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmCanComponentString &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmCanComponentString(QString()) && selectFetchInternalPdmCanComponentString(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmCanComponentString &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmCanComponentString(QString()) && selectFetchInternalPdmCanComponentString(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmCanComponentString(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("SELECT id, bit_mask, can_device_id, sub_device_id, name"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmCanComponentString(const std::function<void(const Database::PdmCanComponentString &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmCanComponentString data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.bitMask = m_query->value(i++).toLongLong();
|
|
data.canDeviceId = m_query->value(i++).toInt();
|
|
data.subDeviceId = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmCanComponentString(qint32 id, Database::PdmCanComponentString &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmCanComponentString &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmCanComponentString(where) || !selectFetchInternalPdmCanComponentString(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmCanComponentString(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmCanComponentString()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmCanComponentString()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_can_component_string")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmCanComponentString end
|
|
|
|
//
|
|
// Struct: Database::PdmChargeType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, predefined_name, dis_entity, properties, charge_legacy_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :predefined_name, :dis_entity, :properties, :charge_legacy_id )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, predefined_name, dis_entity, properties, charge_legacy_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :predefined_name, :dis_entity, :properties, :charge_legacy_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, predefined_name = :predefined_name, dis_entity = :dis_entity, properties = :properties, charge_legacy_id = :charge_legacy_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, predefined_name = :predefined_name, dis_entity = :dis_entity, properties = :properties, charge_legacy_id = :charge_legacy_id"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, predefined_name, dis_entity, properties, charge_legacy_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :predefined_name, :dis_entity, :properties, :charge_legacy_id )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, predefined_name, dis_entity, properties, charge_legacy_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :predefined_name, :dis_entity, :properties, :charge_legacy_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, predefined_name = :predefined_name, dis_entity = :dis_entity, properties = :properties, charge_legacy_id = :charge_legacy_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, predefined_name = :predefined_name, dis_entity = :dis_entity, properties = :properties, charge_legacy_id = :charge_legacy_id"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":predefined_name"), data.predefinedName);
|
|
m_query->bindValue(QStringLiteral(":dis_entity"), data.disEntity);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmChargeType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmChargeType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmChargeType(QString()) && selectFetchInternalPdmChargeType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmChargeType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmChargeType(QString()) && selectFetchInternalPdmChargeType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmChargeType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, short_name, predefined_name, dis_entity, properties, charge_legacy_id"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmChargeType(const std::function<void(const Database::PdmChargeType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmChargeType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.shortName = m_query->value(i++).toString();
|
|
data.predefinedName = m_query->value(i++).toString();
|
|
data.disEntity = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
data.chargeLegacyId = m_query->value(i++).toInt();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmChargeType(qint32 id, Database::PdmChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmChargeType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmChargeType(where) || !selectFetchInternalPdmChargeType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmChargeType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmChargeType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmChargeType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmChargeType end
|
|
|
|
//
|
|
// Struct: Database::PdmChargeTypeIgniterTypeIgniterFunction
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, igniter_function_base_id, igniter_type_id, igniter_function_id, impact_area, impact_radius, hazard_distance, charge_legacy_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :igniter_function_base_id, :igniter_type_id, :igniter_function_id, :impact_area, :impact_radius, :hazard_distance, :charge_legacy_id, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmChargeTypeIgniterTypeIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, igniter_function_base_id, igniter_type_id, igniter_function_id, impact_area, impact_radius, hazard_distance, charge_legacy_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :igniter_function_base_id, :igniter_type_id, :igniter_function_id, :impact_area, :impact_radius, :hazard_distance, :charge_legacy_id, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, igniter_function_base_id = :igniter_function_base_id, igniter_type_id = :igniter_type_id, igniter_function_id = :igniter_function_id, impact_area = :impact_area, impact_radius = :impact_radius, hazard_distance = :hazard_distance, charge_legacy_id = :charge_legacy_id, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, igniter_function_base_id = :igniter_function_base_id, igniter_type_id = :igniter_type_id, igniter_function_id = :igniter_function_id, impact_area = :impact_area, impact_radius = :impact_radius, hazard_distance = :hazard_distance, charge_legacy_id = :charge_legacy_id, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, igniter_function_base_id, igniter_type_id, igniter_function_id, impact_area, impact_radius, hazard_distance, charge_legacy_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :igniter_function_base_id, :igniter_type_id, :igniter_function_id, :impact_area, :impact_radius, :hazard_distance, :charge_legacy_id, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeTypeIgniterTypeIgniterFunction();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, igniter_function_base_id, igniter_type_id, igniter_function_id, impact_area, impact_radius, hazard_distance, charge_legacy_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :igniter_function_base_id, :igniter_type_id, :igniter_function_id, :impact_area, :impact_radius, :hazard_distance, :charge_legacy_id, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, igniter_function_base_id = :igniter_function_base_id, igniter_type_id = :igniter_type_id, igniter_function_id = :igniter_function_id, impact_area = :impact_area, impact_radius = :impact_radius, hazard_distance = :hazard_distance, charge_legacy_id = :charge_legacy_id, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeTypeIgniterTypeIgniterFunction();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, igniter_function_base_id = :igniter_function_base_id, igniter_type_id = :igniter_type_id, igniter_function_id = :igniter_function_id, impact_area = :impact_area, impact_radius = :impact_radius, hazard_distance = :hazard_distance, charge_legacy_id = :charge_legacy_id, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_base_id"), static_cast<int>(data.igniterFunctionBaseId));
|
|
m_query->bindValue(QStringLiteral(":igniter_type_id"), data.igniterTypeId);
|
|
m_query->bindValue(QStringLiteral(":igniter_function_id"), data.igniterFunctionId);
|
|
m_query->bindValue(QStringLiteral(":impact_area"), fixupEmptyJsonString(data.impactArea));
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":hazard_distance"), data.hazardDistance);
|
|
m_query->bindValue(QStringLiteral(":charge_legacy_id"), data.chargeLegacyId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmChargeTypeIgniterTypeIgniterFunction> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmChargeTypeIgniterTypeIgniterFunction(QString()) && selectFetchInternalPdmChargeTypeIgniterTypeIgniterFunction(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmChargeTypeIgniterTypeIgniterFunction(QString()) && selectFetchInternalPdmChargeTypeIgniterTypeIgniterFunction(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmChargeTypeIgniterTypeIgniterFunction(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("SELECT id, charge_type_id, igniter_function_base_id, igniter_type_id, igniter_function_id, impact_area, impact_radius, hazard_distance, charge_legacy_id, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmChargeTypeIgniterTypeIgniterFunction(const std::function<void(const Database::PdmChargeTypeIgniterTypeIgniterFunction &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmChargeTypeIgniterTypeIgniterFunction data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.chargeTypeId = m_query->value(i++).toInt();
|
|
data.igniterFunctionBaseId = static_cast<ProjectDataManagement::IgniterFunctionBase>(m_query->value(i++).toInt());
|
|
data.igniterTypeId = m_query->value(i++).toInt();
|
|
data.igniterFunctionId = m_query->value(i++).toInt();
|
|
data.impactArea = qVariantToJsonString(m_query->value(i++));
|
|
data.impactRadius = m_query->value(i++).toInt();
|
|
data.hazardDistance = m_query->value(i++).toInt();
|
|
data.chargeLegacyId = m_query->value(i++).toInt();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmChargeTypeIgniterTypeIgniterFunction(qint32 id, Database::PdmChargeTypeIgniterTypeIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmChargeTypeIgniterTypeIgniterFunction &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmChargeTypeIgniterTypeIgniterFunction(where) || !selectFetchInternalPdmChargeTypeIgniterTypeIgniterFunction(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmChargeTypeIgniterTypeIgniterFunction(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmChargeTypeIgniterTypeIgniterFunction()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmChargeTypeIgniterTypeIgniterFunction()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_igniter_type_igniter_function")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmChargeTypeIgniterTypeIgniterFunction end
|
|
|
|
//
|
|
// Struct: Database::PdmChargeTypeLoadType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmChargeTypeLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, load_type_id, numbers, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :load_type_id, :numbers, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmChargeTypeLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, load_type_id, numbers, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :load_type_id, :numbers, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, load_type_id = :load_type_id, numbers = :numbers, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmChargeTypeLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, load_type_id = :load_type_id, numbers = :numbers, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmChargeTypeLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, load_type_id, numbers, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :load_type_id, :numbers, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeTypeLoadType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmChargeTypeLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" charge_type_id, load_type_id, numbers, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":charge_type_id, :load_type_id, :numbers, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, load_type_id = :load_type_id, numbers = :numbers, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmChargeTypeLoadType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmChargeTypeLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" charge_type_id = :charge_type_id, load_type_id = :load_type_id, numbers = :numbers, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":load_type_id"), data.loadTypeId);
|
|
m_query->bindValue(QStringLiteral(":numbers"), data.numbers.toPgString());
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmChargeTypeLoadType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmChargeTypeLoadType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmChargeTypeLoadType(QString()) && selectFetchInternalPdmChargeTypeLoadType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmChargeTypeLoadType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmChargeTypeLoadType(QString()) && selectFetchInternalPdmChargeTypeLoadType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmChargeTypeLoadType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, charge_type_id, load_type_id, numbers, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmChargeTypeLoadType(const std::function<void(const Database::PdmChargeTypeLoadType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmChargeTypeLoadType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.chargeTypeId = m_query->value(i++).toInt();
|
|
data.loadTypeId = m_query->value(i++).toInt();
|
|
data.numbers = LtsUtils::IntArray::fromPgString(m_query->value(i++).toString());
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmChargeTypeLoadType(qint32 id, Database::PdmChargeTypeLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmChargeTypeLoadType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmChargeTypeLoadType(where) || !selectFetchInternalPdmChargeTypeLoadType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmChargeTypeLoadType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmChargeTypeLoadType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmChargeTypeLoadType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_charge_type_load_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmChargeTypeLoadType end
|
|
|
|
//
|
|
// Struct: Database::PdmEquipmentSystemEventFilter
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmEquipmentSystemEventFilter &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" equipment_functional_id, sub_device_id, device_specific_code, hgr_mine_search_filter_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":equipment_functional_id, :sub_device_id, :device_specific_code, :hgr_mine_search_filter_type_id )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmEquipmentSystemEventFilter &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" equipment_functional_id, sub_device_id, device_specific_code, hgr_mine_search_filter_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":equipment_functional_id, :sub_device_id, :device_specific_code, :hgr_mine_search_filter_type_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" equipment_functional_id = :equipment_functional_id, sub_device_id = :sub_device_id, device_specific_code = :device_specific_code, hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmEquipmentSystemEventFilter &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" equipment_functional_id = :equipment_functional_id, sub_device_id = :sub_device_id, device_specific_code = :device_specific_code, hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" equipment_functional_id, sub_device_id, device_specific_code, hgr_mine_search_filter_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":equipment_functional_id, :sub_device_id, :device_specific_code, :hgr_mine_search_filter_type_id )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmEquipmentSystemEventFilter();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmEquipmentSystemEventFilter> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" equipment_functional_id, sub_device_id, device_specific_code, hgr_mine_search_filter_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":equipment_functional_id, :sub_device_id, :device_specific_code, :hgr_mine_search_filter_type_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" equipment_functional_id = :equipment_functional_id, sub_device_id = :sub_device_id, device_specific_code = :device_specific_code, hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmEquipmentSystemEventFilter();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmEquipmentSystemEventFilter> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" equipment_functional_id = :equipment_functional_id, sub_device_id = :sub_device_id, device_specific_code = :device_specific_code, hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":equipment_functional_id"), data.equipmentFunctionalId);
|
|
m_query->bindValue(QStringLiteral(":sub_device_id"), data.subDeviceId);
|
|
m_query->bindValue(QStringLiteral(":device_specific_code"), data.deviceSpecificCode);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmEquipmentSystemEventFilter> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmEquipmentSystemEventFilter &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmEquipmentSystemEventFilter(QString()) && selectFetchInternalPdmEquipmentSystemEventFilter(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmEquipmentSystemEventFilter &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmEquipmentSystemEventFilter(QString()) && selectFetchInternalPdmEquipmentSystemEventFilter(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmEquipmentSystemEventFilter(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("SELECT id, equipment_functional_id, sub_device_id, device_specific_code, hgr_mine_search_filter_type_id"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmEquipmentSystemEventFilter(const std::function<void(const Database::PdmEquipmentSystemEventFilter &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmEquipmentSystemEventFilter data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.equipmentFunctionalId = m_query->value(i++).toInt();
|
|
data.subDeviceId = m_query->value(i++).toInt();
|
|
data.deviceSpecificCode = m_query->value(i++).toInt();
|
|
data.hgrMineSearchFilterTypeId = static_cast<ProjectDataManagement::HgrMineSearchFilterType>(m_query->value(i++).toInt());
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmEquipmentSystemEventFilter(qint32 id, Database::PdmEquipmentSystemEventFilter &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmEquipmentSystemEventFilter &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmEquipmentSystemEventFilter(where) || !selectFetchInternalPdmEquipmentSystemEventFilter(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmEquipmentSystemEventFilter(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmEquipmentSystemEventFilter()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmEquipmentSystemEventFilter()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_equipment_system_event_filter")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmEquipmentSystemEventFilter end
|
|
|
|
//
|
|
// Struct: Database::PdmEventFilterHgrMineSearch
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmEventFilterHgrMineSearch &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" hgr_mine_search_filter_type_id, charge_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":hgr_mine_search_filter_type_id, :charge_type_id )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmEventFilterHgrMineSearch &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" hgr_mine_search_filter_type_id, charge_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":hgr_mine_search_filter_type_id, :charge_type_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id, charge_type_id = :charge_type_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmEventFilterHgrMineSearch &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id, charge_type_id = :charge_type_id"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" hgr_mine_search_filter_type_id, charge_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":hgr_mine_search_filter_type_id, :charge_type_id )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmEventFilterHgrMineSearch();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmEventFilterHgrMineSearch> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" hgr_mine_search_filter_type_id, charge_type_id"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":hgr_mine_search_filter_type_id, :charge_type_id )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id, charge_type_id = :charge_type_id"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmEventFilterHgrMineSearch();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmEventFilterHgrMineSearch> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" hgr_mine_search_filter_type_id = :hgr_mine_search_filter_type_id, charge_type_id = :charge_type_id"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":hgr_mine_search_filter_type_id"), static_cast<int>(data.hgrMineSearchFilterTypeId));
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmEventFilterHgrMineSearch> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmEventFilterHgrMineSearch &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmEventFilterHgrMineSearch(QString()) && selectFetchInternalPdmEventFilterHgrMineSearch(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmEventFilterHgrMineSearch &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmEventFilterHgrMineSearch(QString()) && selectFetchInternalPdmEventFilterHgrMineSearch(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmEventFilterHgrMineSearch(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("SELECT id, hgr_mine_search_filter_type_id, charge_type_id"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmEventFilterHgrMineSearch(const std::function<void(const Database::PdmEventFilterHgrMineSearch &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmEventFilterHgrMineSearch data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.hgrMineSearchFilterTypeId = static_cast<ProjectDataManagement::HgrMineSearchFilterType>(m_query->value(i++).toInt());
|
|
data.chargeTypeId = m_query->value(i++).toInt();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmEventFilterHgrMineSearch(qint32 id, Database::PdmEventFilterHgrMineSearch &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmEventFilterHgrMineSearch &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmEventFilterHgrMineSearch(where) || !selectFetchInternalPdmEventFilterHgrMineSearch(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmEventFilterHgrMineSearch(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmEventFilterHgrMineSearch()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmEventFilterHgrMineSearch()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_event_filter_hgr_mine_search")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmEventFilterHgrMineSearch end
|
|
|
|
//
|
|
// Struct: Database::PdmFirePurpose
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmFirePurpose &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmFirePurpose &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmFirePurpose &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmFirePurpose> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmFirePurpose();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmFirePurpose> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmFirePurpose();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmFirePurpose> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmFirePurpose> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmFirePurpose &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmFirePurpose(QString()) && selectFetchInternalPdmFirePurpose(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmFirePurpose &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmFirePurpose(QString()) && selectFetchInternalPdmFirePurpose(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmFirePurpose(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, description, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmFirePurpose(const std::function<void(const Database::PdmFirePurpose &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmFirePurpose data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.description = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmFirePurpose(qint32 id, Database::PdmFirePurpose &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmFirePurpose &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmFirePurpose(where) || !selectFetchInternalPdmFirePurpose(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmFirePurpose(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmFirePurpose()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmFirePurpose()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_fire_purpose")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmFirePurpose end
|
|
|
|
//
|
|
// Struct: Database::PdmGearType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmGearType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, gear_class_id, tas_code, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :gear_class_id, :tas_code, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmGearType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, gear_class_id, tas_code, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :gear_class_id, :tas_code, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, gear_class_id = :gear_class_id, tas_code = :tas_code, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmGearType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, gear_class_id = :gear_class_id, tas_code = :tas_code, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmGearType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, gear_class_id, tas_code, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :gear_class_id, :tas_code, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmGearType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmGearType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, gear_class_id, tas_code, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :gear_class_id, :tas_code, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, gear_class_id = :gear_class_id, tas_code = :tas_code, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmGearType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmGearType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, gear_class_id = :gear_class_id, tas_code = :tas_code, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":gear_class_id"), static_cast<int>(data.gearClassId));
|
|
m_query->bindValue(QStringLiteral(":tas_code"), data.tasCode);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmGearType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmGearType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmGearType(QString()) && selectFetchInternalPdmGearType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmGearType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmGearType(QString()) && selectFetchInternalPdmGearType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmGearType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, gear_class_id, tas_code, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmGearType(const std::function<void(const Database::PdmGearType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmGearType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.gearClassId = static_cast<ProjectDataManagement::GearClass>(m_query->value(i++).toInt());
|
|
data.tasCode = m_query->value(i++).toInt();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmGearType(qint32 id, Database::PdmGearType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmGearType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmGearType(where) || !selectFetchInternalPdmGearType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmGearType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmGearType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmGearType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmGearType end
|
|
|
|
//
|
|
// Struct: Database::PdmGearTypeChargeType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmGearTypeChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" gear_type_id, charge_type_id, max_range, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":gear_type_id, :charge_type_id, :max_range, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmGearTypeChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" gear_type_id, charge_type_id, max_range, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":gear_type_id, :charge_type_id, :max_range, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" gear_type_id = :gear_type_id, charge_type_id = :charge_type_id, max_range = :max_range, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmGearTypeChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" gear_type_id = :gear_type_id, charge_type_id = :charge_type_id, max_range = :max_range, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmGearTypeChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" gear_type_id, charge_type_id, max_range, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":gear_type_id, :charge_type_id, :max_range, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmGearTypeChargeType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmGearTypeChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" gear_type_id, charge_type_id, max_range, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":gear_type_id, :charge_type_id, :max_range, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" gear_type_id = :gear_type_id, charge_type_id = :charge_type_id, max_range = :max_range, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmGearTypeChargeType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmGearTypeChargeType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" gear_type_id = :gear_type_id, charge_type_id = :charge_type_id, max_range = :max_range, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":gear_type_id"), data.gearTypeId);
|
|
m_query->bindValue(QStringLiteral(":charge_type_id"), data.chargeTypeId);
|
|
m_query->bindValue(QStringLiteral(":max_range"), data.maxRange);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmGearTypeChargeType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmGearTypeChargeType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmGearTypeChargeType(QString()) && selectFetchInternalPdmGearTypeChargeType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmGearTypeChargeType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmGearTypeChargeType(QString()) && selectFetchInternalPdmGearTypeChargeType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmGearTypeChargeType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, gear_type_id, charge_type_id, max_range, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmGearTypeChargeType(const std::function<void(const Database::PdmGearTypeChargeType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmGearTypeChargeType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.gearTypeId = m_query->value(i++).toInt();
|
|
data.chargeTypeId = m_query->value(i++).toInt();
|
|
data.maxRange = m_query->value(i++).toInt();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmGearTypeChargeType(qint32 id, Database::PdmGearTypeChargeType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmGearTypeChargeType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmGearTypeChargeType(where) || !selectFetchInternalPdmGearTypeChargeType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmGearTypeChargeType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmGearTypeChargeType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmGearTypeChargeType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_gear_type_charge_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmGearTypeChargeType end
|
|
|
|
//
|
|
// Struct: Database::PdmIgniterFunction
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmIgniterFunction();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmIgniterFunction();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmIgniterFunction> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmIgniterFunction> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmIgniterFunction &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmIgniterFunction(QString()) && selectFetchInternalPdmIgniterFunction(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmIgniterFunction &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmIgniterFunction(QString()) && selectFetchInternalPdmIgniterFunction(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmIgniterFunction(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, short_name, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmIgniterFunction(const std::function<void(const Database::PdmIgniterFunction &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmIgniterFunction data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.shortName = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmIgniterFunction(qint32 id, Database::PdmIgniterFunction &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmIgniterFunction &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmIgniterFunction(where) || !selectFetchInternalPdmIgniterFunction(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmIgniterFunction(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmIgniterFunction()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmIgniterFunction()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_function")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmIgniterFunction end
|
|
|
|
//
|
|
// Struct: Database::PdmIgniterType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmIgniterType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmIgniterType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmIgniterType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmIgniterType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmIgniterType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmIgniterType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmIgniterType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmIgniterType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmIgniterType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmIgniterType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmIgniterType(QString()) && selectFetchInternalPdmIgniterType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmIgniterType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmIgniterType(QString()) && selectFetchInternalPdmIgniterType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmIgniterType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, short_name, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmIgniterType(const std::function<void(const Database::PdmIgniterType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmIgniterType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.shortName = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmIgniterType(qint32 id, Database::PdmIgniterType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmIgniterType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmIgniterType(where) || !selectFetchInternalPdmIgniterType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmIgniterType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmIgniterType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmIgniterType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_igniter_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmIgniterType end
|
|
|
|
//
|
|
// Struct: Database::PdmLanguage
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmLanguage &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code, db_locale"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code, :db_locale )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmLanguage &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code, db_locale"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code, :db_locale )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code, db_locale = :db_locale"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmLanguage &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code, db_locale = :db_locale"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmLanguage> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code, db_locale"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code, :db_locale )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLanguage();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmLanguage> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code, db_locale"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code, :db_locale )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code, db_locale = :db_locale"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLanguage();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmLanguage> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code, db_locale = :db_locale"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":db_locale"), data.dbLocale);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmLanguage> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmLanguage &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmLanguage(QString()) && selectFetchInternalPdmLanguage(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmLanguage &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmLanguage(QString()) && selectFetchInternalPdmLanguage(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmLanguage(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, iso_code, db_locale"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmLanguage(const std::function<void(const Database::PdmLanguage &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmLanguage data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.isoCode = m_query->value(i++).toString();
|
|
data.dbLocale = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmLanguage(qint32 id, Database::PdmLanguage &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmLanguage &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmLanguage(where) || !selectFetchInternalPdmLanguage(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmLanguage(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmLanguage()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmLanguage()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_hmi")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmLanguage end
|
|
|
|
//
|
|
// Struct: Database::PdmLanguageXdu
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmLanguageXdu &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmLanguageXdu &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmLanguageXdu &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmLanguageXdu> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLanguageXdu();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmLanguageXdu> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, iso_code"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :iso_code )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLanguageXdu();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmLanguageXdu> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, iso_code = :iso_code"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmLanguageXdu> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmLanguageXdu &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmLanguageXdu(QString()) && selectFetchInternalPdmLanguageXdu(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmLanguageXdu &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmLanguageXdu(QString()) && selectFetchInternalPdmLanguageXdu(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmLanguageXdu(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, iso_code"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmLanguageXdu(const std::function<void(const Database::PdmLanguageXdu &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmLanguageXdu data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.isoCode = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmLanguageXdu(qint32 id, Database::PdmLanguageXdu &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmLanguageXdu &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmLanguageXdu(where) || !selectFetchInternalPdmLanguageXdu(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmLanguageXdu(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmLanguageXdu()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmLanguageXdu()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_language_xdu")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmLanguageXdu end
|
|
|
|
//
|
|
// Struct: Database::PdmLoadType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLoadType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, short_name, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :short_name, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmLoadType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmLoadType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, short_name = :short_name, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":short_name"), data.shortName);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmLoadType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmLoadType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmLoadType(QString()) && selectFetchInternalPdmLoadType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmLoadType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmLoadType(QString()) && selectFetchInternalPdmLoadType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmLoadType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, short_name, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmLoadType(const std::function<void(const Database::PdmLoadType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmLoadType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.shortName = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmLoadType(qint32 id, Database::PdmLoadType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmLoadType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmLoadType(where) || !selectFetchInternalPdmLoadType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmLoadType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmLoadType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmLoadType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_load_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmLoadType end
|
|
|
|
//
|
|
// Struct: Database::PdmNuclearPreset
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmNuclearPreset &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, detonation_value, impact_radius, border_length_inner, border_length_outer"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :detonation_value, :impact_radius, :border_length_inner, :border_length_outer )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmNuclearPreset &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, detonation_value, impact_radius, border_length_inner, border_length_outer"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :detonation_value, :impact_radius, :border_length_inner, :border_length_outer )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, detonation_value = :detonation_value, impact_radius = :impact_radius, border_length_inner = :border_length_inner, border_length_outer = :border_length_outer"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmNuclearPreset &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, detonation_value = :detonation_value, impact_radius = :impact_radius, border_length_inner = :border_length_inner, border_length_outer = :border_length_outer"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmNuclearPreset> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, detonation_value, impact_radius, border_length_inner, border_length_outer"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :detonation_value, :impact_radius, :border_length_inner, :border_length_outer )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmNuclearPreset();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmNuclearPreset> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, detonation_value, impact_radius, border_length_inner, border_length_outer"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :detonation_value, :impact_radius, :border_length_inner, :border_length_outer )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, detonation_value = :detonation_value, impact_radius = :impact_radius, border_length_inner = :border_length_inner, border_length_outer = :border_length_outer"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmNuclearPreset();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmNuclearPreset> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, detonation_value = :detonation_value, impact_radius = :impact_radius, border_length_inner = :border_length_inner, border_length_outer = :border_length_outer"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":detonation_value"), data.detonationValue);
|
|
m_query->bindValue(QStringLiteral(":impact_radius"), data.impactRadius);
|
|
m_query->bindValue(QStringLiteral(":border_length_inner"), data.borderLengthInner);
|
|
m_query->bindValue(QStringLiteral(":border_length_outer"), data.borderLengthOuter);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmNuclearPreset> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmNuclearPreset &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmNuclearPreset(QString()) && selectFetchInternalPdmNuclearPreset(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmNuclearPreset &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmNuclearPreset(QString()) && selectFetchInternalPdmNuclearPreset(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmNuclearPreset(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, detonation_value, impact_radius, border_length_inner, border_length_outer"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmNuclearPreset(const std::function<void(const Database::PdmNuclearPreset &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmNuclearPreset data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.detonationValue = m_query->value(i++).toDouble();
|
|
data.impactRadius = m_query->value(i++).toDouble();
|
|
data.borderLengthInner = m_query->value(i++).toDouble();
|
|
data.borderLengthOuter = m_query->value(i++).toDouble();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmNuclearPreset(qint32 id, Database::PdmNuclearPreset &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmNuclearPreset &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmNuclearPreset(where) || !selectFetchInternalPdmNuclearPreset(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmNuclearPreset(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmNuclearPreset()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmNuclearPreset()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_nuclear_preset")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmNuclearPreset end
|
|
|
|
//
|
|
// Struct: Database::PdmRadioGroup
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmRadioGroup &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, base_group, issi, group_issi1, group_issi2, radio_hostname, radio_port, radio_backup_hostname, radio_backup_port"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :base_group, :issi, :group_issi1, :group_issi2, :radio_hostname, :radio_port, :radio_backup_hostname, :radio_backup_port )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmRadioGroup &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, base_group, issi, group_issi1, group_issi2, radio_hostname, radio_port, radio_backup_hostname, radio_backup_port"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :base_group, :issi, :group_issi1, :group_issi2, :radio_hostname, :radio_port, :radio_backup_hostname, :radio_backup_port )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, base_group = :base_group, issi = :issi, group_issi1 = :group_issi1, group_issi2 = :group_issi2, radio_hostname = :radio_hostname, radio_port = :radio_port, radio_backup_hostname = :radio_backup_hostname, radio_backup_port = :radio_backup_port"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmRadioGroup &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, base_group = :base_group, issi = :issi, group_issi1 = :group_issi1, group_issi2 = :group_issi2, radio_hostname = :radio_hostname, radio_port = :radio_port, radio_backup_hostname = :radio_backup_hostname, radio_backup_port = :radio_backup_port"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmRadioGroup> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, base_group, issi, group_issi1, group_issi2, radio_hostname, radio_port, radio_backup_hostname, radio_backup_port"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :base_group, :issi, :group_issi1, :group_issi2, :radio_hostname, :radio_port, :radio_backup_hostname, :radio_backup_port )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmRadioGroup();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmRadioGroup> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, base_group, issi, group_issi1, group_issi2, radio_hostname, radio_port, radio_backup_hostname, radio_backup_port"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :base_group, :issi, :group_issi1, :group_issi2, :radio_hostname, :radio_port, :radio_backup_hostname, :radio_backup_port )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, base_group = :base_group, issi = :issi, group_issi1 = :group_issi1, group_issi2 = :group_issi2, radio_hostname = :radio_hostname, radio_port = :radio_port, radio_backup_hostname = :radio_backup_hostname, radio_backup_port = :radio_backup_port"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmRadioGroup();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmRadioGroup> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, base_group = :base_group, issi = :issi, group_issi1 = :group_issi1, group_issi2 = :group_issi2, radio_hostname = :radio_hostname, radio_port = :radio_port, radio_backup_hostname = :radio_backup_hostname, radio_backup_port = :radio_backup_port"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":base_group"), data.baseGroup);
|
|
m_query->bindValue(QStringLiteral(":issi"), data.issi);
|
|
m_query->bindValue(QStringLiteral(":group_issi1"), data.groupIssi1);
|
|
m_query->bindValue(QStringLiteral(":group_issi2"), data.groupIssi2);
|
|
m_query->bindValue(QStringLiteral(":radio_hostname"), data.radioHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_port"), data.radioPort);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_hostname"), data.radioBackupHostname);
|
|
m_query->bindValue(QStringLiteral(":radio_backup_port"), data.radioBackupPort);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmRadioGroup> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmRadioGroup &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmRadioGroup(QString()) && selectFetchInternalPdmRadioGroup(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmRadioGroup &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmRadioGroup(QString()) && selectFetchInternalPdmRadioGroup(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmRadioGroup(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, base_group, issi, group_issi1, group_issi2, radio_hostname, radio_port, radio_backup_hostname, radio_backup_port"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmRadioGroup(const std::function<void(const Database::PdmRadioGroup &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmRadioGroup data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.baseGroup = m_query->value(i++).toBool();
|
|
data.issi = m_query->value(i++).toInt();
|
|
data.groupIssi1 = m_query->value(i++).toInt();
|
|
data.groupIssi2 = m_query->value(i++).toInt();
|
|
data.radioHostname = m_query->value(i++).toString();
|
|
data.radioPort = m_query->value(i++).toInt();
|
|
data.radioBackupHostname = m_query->value(i++).toString();
|
|
data.radioBackupPort = m_query->value(i++).toInt();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmRadioGroup(qint32 id, Database::PdmRadioGroup &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmRadioGroup &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmRadioGroup(where) || !selectFetchInternalPdmRadioGroup(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmRadioGroup(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmRadioGroup()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmRadioGroup()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_radio_group")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmRadioGroup end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationInjury
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationInjury &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, kind, place_1, place_2, vbg"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :kind, :place_1, :place_2, :vbg )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationInjury &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, kind, place_1, place_2, vbg"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :kind, :place_1, :place_2, :vbg )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, kind = :kind, place_1 = :place_1, place_2 = :place_2, vbg = :vbg"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationInjury &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, kind = :kind, place_1 = :place_1, place_2 = :place_2, vbg = :vbg"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationInjury> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, kind, place_1, place_2, vbg"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :kind, :place_1, :place_2, :vbg )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationInjury> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, kind, place_1, place_2, vbg"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :kind, :place_1, :place_2, :vbg )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, kind = :kind, place_1 = :place_1, place_2 = :place_2, vbg = :vbg"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationInjury> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, kind = :kind, place_1 = :place_1, place_2 = :place_2, vbg = :vbg"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":kind"), data.kind);
|
|
m_query->bindValue(QStringLiteral(":place_1"), data.place1);
|
|
m_query->bindValue(QStringLiteral(":place_2"), data.place2);
|
|
m_query->bindValue(QStringLiteral(":vbg"), data.vbg);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationInjury> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationInjury &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationInjury(QString()) && selectFetchInternalPdmSanitationInjury(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationInjury &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationInjury(QString()) && selectFetchInternalPdmSanitationInjury(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationInjury(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, kind, place_1, place_2, vbg"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationInjury(const std::function<void(const Database::PdmSanitationInjury &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationInjury data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.kind = m_query->value(i++).toInt();
|
|
data.place1 = m_query->value(i++).toInt();
|
|
data.place2 = m_query->value(i++).toInt();
|
|
data.vbg = m_query->value(i++).toInt();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationInjury(qint32 id, Database::PdmSanitationInjury &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationInjury &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationInjury(where) || !selectFetchInternalPdmSanitationInjury(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationInjury(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationInjury()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationInjury()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationInjury end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationInjuryKind
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationInjuryKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationInjuryKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationInjuryKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationInjuryKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationInjuryKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationInjuryKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationInjuryKind> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationInjuryKind &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationInjuryKind(QString()) && selectFetchInternalPdmSanitationInjuryKind(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationInjuryKind &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationInjuryKind(QString()) && selectFetchInternalPdmSanitationInjuryKind(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationInjuryKind(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, version"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationInjuryKind(const std::function<void(const Database::PdmSanitationInjuryKind &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationInjuryKind data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.version = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationInjuryKind(qint32 id, Database::PdmSanitationInjuryKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationInjuryKind &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationInjuryKind(where) || !selectFetchInternalPdmSanitationInjuryKind(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationInjuryKind(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationInjuryKind()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationInjuryKind()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_kind")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationInjuryKind end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationInjuryPlace1
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationInjuryPlace1 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationInjuryPlace1 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationInjuryPlace1 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationInjuryPlace1> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationInjuryPlace1> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationInjuryPlace1> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationInjuryPlace1> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationInjuryPlace1 &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationInjuryPlace1(QString()) && selectFetchInternalPdmSanitationInjuryPlace1(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationInjuryPlace1 &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationInjuryPlace1(QString()) && selectFetchInternalPdmSanitationInjuryPlace1(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationInjuryPlace1(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, version"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationInjuryPlace1(const std::function<void(const Database::PdmSanitationInjuryPlace1 &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationInjuryPlace1 data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.version = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationInjuryPlace1(qint32 id, Database::PdmSanitationInjuryPlace1 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationInjuryPlace1 &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationInjuryPlace1(where) || !selectFetchInternalPdmSanitationInjuryPlace1(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationInjuryPlace1(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationInjuryPlace1()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationInjuryPlace1()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_1")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationInjuryPlace1 end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationInjuryPlace2
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationInjuryPlace2 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationInjuryPlace2 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationInjuryPlace2 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationInjuryPlace2> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationInjuryPlace2> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationInjuryPlace2> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationInjuryPlace2> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationInjuryPlace2 &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationInjuryPlace2(QString()) && selectFetchInternalPdmSanitationInjuryPlace2(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationInjuryPlace2 &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationInjuryPlace2(QString()) && selectFetchInternalPdmSanitationInjuryPlace2(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationInjuryPlace2(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, version"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationInjuryPlace2(const std::function<void(const Database::PdmSanitationInjuryPlace2 &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationInjuryPlace2 data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.version = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationInjuryPlace2(qint32 id, Database::PdmSanitationInjuryPlace2 &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationInjuryPlace2 &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationInjuryPlace2(where) || !selectFetchInternalPdmSanitationInjuryPlace2(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationInjuryPlace2(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationInjuryPlace2()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationInjuryPlace2()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_injury_place_2")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationInjuryPlace2 end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationMaterial
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationMaterial &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :version )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationMaterial &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationMaterial &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationMaterial> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :version )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmSanitationMaterial();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationMaterial> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, description, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :description, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmSanitationMaterial();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationMaterial> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, description = :description, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":description"), data.description);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationMaterial> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationMaterial &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationMaterial(QString()) && selectFetchInternalPdmSanitationMaterial(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationMaterial &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationMaterial(QString()) && selectFetchInternalPdmSanitationMaterial(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationMaterial(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, description, version"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationMaterial(const std::function<void(const Database::PdmSanitationMaterial &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationMaterial data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.description = m_query->value(i++).toString();
|
|
data.version = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationMaterial(qint32 id, Database::PdmSanitationMaterial &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationMaterial &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationMaterial(where) || !selectFetchInternalPdmSanitationMaterial(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationMaterial(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationMaterial()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationMaterial()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_material")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationMaterial end
|
|
|
|
//
|
|
// Struct: Database::PdmSanitationProcedures
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmSanitationProcedures &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, type, type_id, minimum_qualification, long_name, data_code, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :type, :type_id, :minimum_qualification, :long_name, :data_code, :version )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmSanitationProcedures &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, type, type_id, minimum_qualification, long_name, data_code, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :type, :type_id, :minimum_qualification, :long_name, :data_code, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, type = :type, type_id = :type_id, minimum_qualification = :minimum_qualification, long_name = :long_name, data_code = :data_code, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmSanitationProcedures &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, type = :type, type_id = :type_id, minimum_qualification = :minimum_qualification, long_name = :long_name, data_code = :data_code, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmSanitationProcedures> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, type, type_id, minimum_qualification, long_name, data_code, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :type, :type_id, :minimum_qualification, :long_name, :data_code, :version )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmSanitationProcedures> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" id, name, type, type_id, minimum_qualification, long_name, data_code, version"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":id, :name, :type, :type_id, :minimum_qualification, :long_name, :data_code, :version )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, type = :type, type_id = :type_id, minimum_qualification = :minimum_qualification, long_name = :long_name, data_code = :data_code, version = :version"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmSanitationProcedures> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" id = :id, name = :name, type = :type, type_id = :type_id, minimum_qualification = :minimum_qualification, long_name = :long_name, data_code = :data_code, version = :version"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":type"), data.type);
|
|
m_query->bindValue(QStringLiteral(":type_id"), data.typeId);
|
|
m_query->bindValue(QStringLiteral(":minimum_qualification"), data.minimumQualification);
|
|
m_query->bindValue(QStringLiteral(":long_name"), data.longName);
|
|
m_query->bindValue(QStringLiteral(":data_code"), data.dataCode);
|
|
m_query->bindValue(QStringLiteral(":version"), data.version);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmSanitationProcedures> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmSanitationProcedures &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmSanitationProcedures(QString()) && selectFetchInternalPdmSanitationProcedures(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmSanitationProcedures &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmSanitationProcedures(QString()) && selectFetchInternalPdmSanitationProcedures(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmSanitationProcedures(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, type, type_id, minimum_qualification, long_name, data_code, version"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmSanitationProcedures(const std::function<void(const Database::PdmSanitationProcedures &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmSanitationProcedures data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.type = m_query->value(i++).toString();
|
|
data.typeId = m_query->value(i++).toInt();
|
|
data.minimumQualification = m_query->value(i++).toInt();
|
|
data.longName = m_query->value(i++).toString();
|
|
data.dataCode = m_query->value(i++).toLongLong();
|
|
data.version = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmSanitationProcedures(qint32 id, Database::PdmSanitationProcedures &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmSanitationProcedures &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmSanitationProcedures(where) || !selectFetchInternalPdmSanitationProcedures(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmSanitationProcedures(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmSanitationProcedures()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmSanitationProcedures()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_sanitation_procedures")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmSanitationProcedures end
|
|
|
|
//
|
|
// Struct: Database::PdmTargetSubType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetSubType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetSubType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmTargetSubType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmTargetSubType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmTargetSubType(QString()) && selectFetchInternalPdmTargetSubType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmTargetSubType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmTargetSubType(QString()) && selectFetchInternalPdmTargetSubType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmTargetSubType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, abbreviation, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmTargetSubType(const std::function<void(const Database::PdmTargetSubType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmTargetSubType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.abbreviation = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmTargetSubType(qint32 id, Database::PdmTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmTargetSubType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmTargetSubType(where) || !selectFetchInternalPdmTargetSubType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmTargetSubType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmTargetSubType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmTargetSubType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_subtype")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmTargetSubType end
|
|
|
|
//
|
|
// Struct: Database::PdmTargetType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmTargetType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmTargetType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmTargetType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmTargetType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmTargetType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" name, abbreviation, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":name, :abbreviation, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmTargetType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" name = :name, abbreviation = :abbreviation, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
m_query->bindValue(QStringLiteral(":abbreviation"), data.abbreviation);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmTargetType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmTargetType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmTargetType(QString()) && selectFetchInternalPdmTargetType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmTargetType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmTargetType(QString()) && selectFetchInternalPdmTargetType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmTargetType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("SELECT id, name, abbreviation, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmTargetType(const std::function<void(const Database::PdmTargetType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmTargetType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.name = m_query->value(i++).toString();
|
|
data.abbreviation = m_query->value(i++).toString();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmTargetType(qint32 id, Database::PdmTargetType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmTargetType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmTargetType(where) || !selectFetchInternalPdmTargetType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmTargetType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmTargetType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmTargetType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmTargetType end
|
|
|
|
//
|
|
// Struct: Database::PdmTargetTypeTargetSubType
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmTargetTypeTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" target_type_id, target_subtype_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":target_type_id, :target_subtype_id, :properties )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmTargetTypeTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" target_type_id, target_subtype_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":target_type_id, :target_subtype_id, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" target_type_id = :target_type_id, target_subtype_id = :target_subtype_id, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmTargetTypeTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" target_type_id = :target_type_id, target_subtype_id = :target_subtype_id, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmTargetTypeTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" target_type_id, target_subtype_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":target_type_id, :target_subtype_id, :properties )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetTypeTargetSubType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmTargetTypeTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" target_type_id, target_subtype_id, properties"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":target_type_id, :target_subtype_id, :properties )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" target_type_id = :target_type_id, target_subtype_id = :target_subtype_id, properties = :properties"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTargetTypeTargetSubType();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmTargetTypeTargetSubType> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" target_type_id = :target_type_id, target_subtype_id = :target_subtype_id, properties = :properties"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":target_type_id"), data.targetTypeId);
|
|
m_query->bindValue(QStringLiteral(":target_subtype_id"), data.targetSubtypeId);
|
|
m_query->bindValue(QStringLiteral(":properties"), fixupEmptyJsonString(data.properties));
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmTargetTypeTargetSubType> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmTargetTypeTargetSubType &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmTargetTypeTargetSubType(QString()) && selectFetchInternalPdmTargetTypeTargetSubType(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmTargetTypeTargetSubType &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmTargetTypeTargetSubType(QString()) && selectFetchInternalPdmTargetTypeTargetSubType(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmTargetTypeTargetSubType(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("SELECT id, target_type_id, target_subtype_id, properties"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmTargetTypeTargetSubType(const std::function<void(const Database::PdmTargetTypeTargetSubType &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmTargetTypeTargetSubType data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.targetTypeId = m_query->value(i++).toInt();
|
|
data.targetSubtypeId = m_query->value(i++).toInt();
|
|
data.properties = qVariantToJsonString(m_query->value(i++));
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmTargetTypeTargetSubType(qint32 id, Database::PdmTargetTypeTargetSubType &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmTargetTypeTargetSubType &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmTargetTypeTargetSubType(where) || !selectFetchInternalPdmTargetTypeTargetSubType(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmTargetTypeTargetSubType(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmTargetTypeTargetSubType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmTargetTypeTargetSubType()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_target_type_target_subtype")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmTargetTypeTargetSubType end
|
|
|
|
//
|
|
// Struct: Database::PdmTranslation
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmTranslation &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = data.id != 0;
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" iso_code, context, key, disambiguation, translation"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":iso_code, :context, :key, :disambiguation, :translation )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmTranslation &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" iso_code, context, key, disambiguation, translation"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":iso_code, :context, :key, :disambiguation, :translation )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" iso_code = :iso_code, context = :context, key = :key, disambiguation = :disambiguation, translation = :translation"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmTranslation &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" iso_code = :iso_code, context = :context, key = :key, disambiguation = :disambiguation, translation = :translation"
|
|
" WHERE id = :id"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmTranslation> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = cont[0].id != 0;
|
|
// the first element determines the stmt to be used
|
|
if (bInsertWithKey)
|
|
{
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
}
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" iso_code, context, key, disambiguation, translation"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":iso_code, :context, :key, :disambiguation, :translation )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTranslation();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmTranslation> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
const bool bInsertWithKey = true;
|
|
keyColumnInsertVal = QStringLiteral(" :id, ");
|
|
keyColumnInsertKey = QStringLiteral("id, ");
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("id ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" iso_code, context, key, disambiguation, translation"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":iso_code, :context, :key, :disambiguation, :translation )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" iso_code = :iso_code, context = :context, key = :key, disambiguation = :disambiguation, translation = :translation"
|
|
" WHERE excluded.id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
if (bInsertWithKey)
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
if (data.id == 0)
|
|
data.id = m_query->lastInsertId().toInt();
|
|
}
|
|
}
|
|
|
|
|
|
if (bInsertWithKey)
|
|
fixUpSequencePdmTranslation();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmTranslation> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" iso_code = :iso_code, context = :context, key = :key, disambiguation = :disambiguation, translation = :translation"
|
|
" WHERE id = :id"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":iso_code"), data.isoCode);
|
|
m_query->bindValue(QStringLiteral(":context"), data.context);
|
|
m_query->bindValue(QStringLiteral(":key"), data.key);
|
|
m_query->bindValue(QStringLiteral(":disambiguation"), data.disambiguation);
|
|
m_query->bindValue(QStringLiteral(":translation"), data.translation);
|
|
m_query->bindValue(QStringLiteral(":id"), data.id);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmTranslation> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmTranslation &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmTranslation(QString()) && selectFetchInternalPdmTranslation(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmTranslation &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmTranslation(QString()) && selectFetchInternalPdmTranslation(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmTranslation(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("SELECT id, iso_code, context, key, disambiguation, translation"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmTranslation(const std::function<void(const Database::PdmTranslation &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmTranslation data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.id = m_query->value(i++).toInt();
|
|
data.isoCode = m_query->value(i++).toString();
|
|
data.context = m_query->value(i++).toString();
|
|
data.key = m_query->value(i++).toString();
|
|
data.disambiguation = m_query->value(i++).toString();
|
|
data.translation = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmTranslation(qint32 id, Database::PdmTranslation &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmTranslation &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE id = %1").arg(id);
|
|
if (!selectPrepareInternalPdmTranslation(where) || !selectFetchInternalPdmTranslation(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmTranslation(qint32 id)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE id = ") +
|
|
QString::number(id));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmTranslation()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_id_seq', COALESCE((SELECT MAX(id)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmTranslation()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_translation")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmTranslation end
|
|
|
|
//
|
|
// Struct: Database::PdmVulnerabilityKind
|
|
//
|
|
bool DatabaseInterfaceImpl::insert(Database::PdmVulnerabilityKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" ta_vulnerability_kind, player_type_class_id, vulnerability_class_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":ta_vulnerability_kind, :player_type_class_id, :vulnerability_class_id, :name )"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(Database::PdmVulnerabilityKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
|
|
keyColumnInsertKeyConflict = QStringLiteral("ta_vulnerability_kind ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" ta_vulnerability_kind, player_type_class_id, vulnerability_class_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":ta_vulnerability_kind, :player_type_class_id, :vulnerability_class_id, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" ta_vulnerability_kind = :ta_vulnerability_kind, player_type_class_id = :player_type_class_id, vulnerability_class_id = :vulnerability_class_id, name = :name"
|
|
" WHERE excluded.ta_vulnerability_kind = :ta_vulnerability_kind"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::update(const Database::PdmVulnerabilityKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" ta_vulnerability_kind = :ta_vulnerability_kind, player_type_class_id = :player_type_class_id, vulnerability_class_id = :vulnerability_class_id, name = :name"
|
|
" WHERE ta_vulnerability_kind = :ta_vulnerability_kind"));
|
|
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::insert(std::vector<Database::PdmVulnerabilityKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertVal;
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" ta_vulnerability_kind, player_type_class_id, vulnerability_class_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":ta_vulnerability_kind, :player_type_class_id, :vulnerability_class_id, :name )"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::upsert(std::vector<Database::PdmVulnerabilityKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
|
|
QString keyColumnInsertKey;
|
|
QString keyColumnInsertKeyConflict;
|
|
QString keyColumnInsertVal;
|
|
// the first element determines the stmt to be used
|
|
keyColumnInsertKeyConflict = QStringLiteral("ta_vulnerability_kind ");
|
|
|
|
const QString stmt(QStringLiteral("INSERT INTO ") + tableName +
|
|
QStringLiteral(" (") + keyColumnInsertKey +
|
|
QStringLiteral(" ta_vulnerability_kind, player_type_class_id, vulnerability_class_id, name"
|
|
" ) VALUES (") + keyColumnInsertVal +
|
|
QStringLiteral(":ta_vulnerability_kind, :player_type_class_id, :vulnerability_class_id, :name )") +
|
|
QStringLiteral(" ON CONFLICT (") + keyColumnInsertKeyConflict + QStringLiteral(") DO UPDATE ") +
|
|
QStringLiteral(" SET"
|
|
" ta_vulnerability_kind = :ta_vulnerability_kind, player_type_class_id = :player_type_class_id, vulnerability_class_id = :vulnerability_class_id, name = :name"
|
|
" WHERE excluded.ta_vulnerability_kind = :ta_vulnerability_kind"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (auto &data : cont)
|
|
{
|
|
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// current only implemented for 'plain' structures with only one affected table
|
|
bool DatabaseInterfaceImpl::update(const std::vector<Database::PdmVulnerabilityKind> &cont)
|
|
{
|
|
if (cont.empty())
|
|
return true;
|
|
|
|
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("UPDATE ") + tableName +
|
|
QStringLiteral(" SET"
|
|
" ta_vulnerability_kind = :ta_vulnerability_kind, player_type_class_id = :player_type_class_id, vulnerability_class_id = :vulnerability_class_id, name = :name"
|
|
" WHERE ta_vulnerability_kind = :ta_vulnerability_kind"));
|
|
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
if (!m_query->prepare(stmt))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
for (const auto &data : cont)
|
|
{
|
|
|
|
m_query->bindValue(QStringLiteral(":ta_vulnerability_kind"), data.taVulnerabilityKind);
|
|
m_query->bindValue(QStringLiteral(":player_type_class_id"), data.playerTypeClassId);
|
|
m_query->bindValue(QStringLiteral(":vulnerability_class_id"), static_cast<int>(data.vulnerabilityClassId));
|
|
m_query->bindValue(QStringLiteral(":name"), data.name);
|
|
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::select(QVector<Database::PdmVulnerabilityKind> &dataVec)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const auto cb =[&dataVec] (const Database::PdmVulnerabilityKind &data)
|
|
{
|
|
dataVec.push_back(data);
|
|
};
|
|
return selectPrepareInternalPdmVulnerabilityKind(QString()) && selectFetchInternalPdmVulnerabilityKind(cb);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::select(const std::function<void(const Database::PdmVulnerabilityKind &data)> &cb)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
return selectPrepareInternalPdmVulnerabilityKind(QString()) && selectFetchInternalPdmVulnerabilityKind(cb);
|
|
}
|
|
|
|
|
|
|
|
bool DatabaseInterfaceImpl::selectPrepareInternalPdmVulnerabilityKind(const QString &where)
|
|
{
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("SELECT ta_vulnerability_kind, player_type_class_id, vulnerability_class_id, name"
|
|
" FROM ") + tableName + where);
|
|
return m_query->prepare(stmt);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectFetchInternalPdmVulnerabilityKind(const std::function<void(const Database::PdmVulnerabilityKind &data)> &cb)
|
|
{
|
|
if (!m_query->exec(m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
Database::PdmVulnerabilityKind data;
|
|
while (m_query->next())
|
|
{
|
|
int i = 0;
|
|
data.taVulnerabilityKind = m_query->value(i++).toInt();
|
|
data.playerTypeClassId = m_query->value(i++).toInt();
|
|
data.vulnerabilityClassId = static_cast<ProjectDataManagement::VulnerabilityClass>(m_query->value(i++).toInt());
|
|
data.name = m_query->value(i++).toString();
|
|
cb(data);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::selectPdmVulnerabilityKind(qint32 taVulnerabilityKind, Database::PdmVulnerabilityKind &data)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
int iCnt = 0;
|
|
const auto cb =[&data, &iCnt] (const Database::PdmVulnerabilityKind &content)
|
|
{
|
|
data = content;
|
|
++iCnt;
|
|
};
|
|
const QString where = QStringLiteral(" WHERE ta_vulnerability_kind = %1").arg(taVulnerabilityKind);
|
|
if (!selectPrepareInternalPdmVulnerabilityKind(where) || !selectFetchInternalPdmVulnerabilityKind(cb))
|
|
return false;
|
|
|
|
return (iCnt == 1);
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::removePdmVulnerabilityKind(qint32 taVulnerabilityKind)
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("DELETE FROM ") + tableName +
|
|
QStringLiteral(" WHERE ta_vulnerability_kind = ") +
|
|
QString::number(taVulnerabilityKind));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool DatabaseInterfaceImpl::fixUpSequencePdmVulnerabilityKind()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("SELECT setval('") + tableName + QStringLiteral("_ta_vulnerability_kind_seq', COALESCE((SELECT MAX(ta_vulnerability_kind)+1 FROM ") +
|
|
tableName + QStringLiteral("), 1),false)"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DatabaseInterfaceImpl::truncatePdmVulnerabilityKind()
|
|
{
|
|
SqlQueryJanitor janitor(m_query);
|
|
const QString tableName(getTableName(QStringLiteral("pdm_vulnerability_kind")));
|
|
const QString stmt(QStringLiteral("TRUNCATE TABLE ") + tableName + QStringLiteral(" CASCADE"));
|
|
|
|
if (!m_query->exec(stmt, m_bEmitMessageOnError))
|
|
{
|
|
m_lastError = m_query->lastError();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Database::PdmVulnerabilityKind end
|
|
|
|
|
|
|
|
} // namespace ProjectDataManagement
|
|
|